This is an archive of the discontinued LLVM Phabricator instance.

Differential D127470

[libcxx][AIX] Switch build compiler to clang
ClosedPublic

Authored by Jake-Egan on Jun 9 2022, 8:24 PM.

Details

Reviewers
daltenty
ldionne
Group Reviewers
Restricted Project
Restricted Project
Restricted Project
Commits
rG1cf4113952ae: [libcxx][AIX] Switch build compiler to clang
Summary

This patch switches the build compiler for AIX from ibm-clang to clang. ibm-clang++_r has -pthread by default, but clang for AIX doesn't, so -pthread had to be added to the test config. A bunch of tests now pass, so the XFAIL was removed. This patch also switch the build to use the visibility support available in clang-15 to control symbols exported by the shared library (AIX traditionally uses explicit export lists for this purpose).

Diff Detail

Event Timeline

Jake-Egan created this revision.Jun 9 2022, 8:24 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 9 2022, 8:24 PM
Herald added subscribers: arphaman, arichardson, mgorny. · View Herald Transcript
Jake-Egan requested review of this revision.Jun 9 2022, 8:24 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJun 9 2022, 8:24 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Jake-Egan edited the summary of this revision. (Show Details)Jun 9 2022, 8:34 PM
Jake-Egan added a reviewer: daltenty.
Jake-Egan updated this revision to Diff 435785.Jun 9 2022, 8:40 PM
Jake-Egan edited the summary of this revision. (Show Details)

Fixed typo

Harbormaster completed remote builds in B168996: Diff 435785.Jun 9 2022, 9:41 PM
Jake-Egan updated this revision to Diff 435959.Jun 10 2022, 9:59 AM

Rebuild CI

Harbormaster completed remote builds in B169105: Diff 435959.Jun 10 2022, 11:58 AM
Jake-Egan mentioned this in D124165: [libcxx][AIX] Enable ABI list checking for XCOFF.Jun 10 2022, 7:16 PM
Jake-Egan updated this revision to Diff 436093.Jun 10 2022, 8:44 PM

Set ar path to hopefully fix the CI (llvm-ar not recognizing -X option)

Harbormaster completed remote builds in B169200: Diff 436093.Jun 10 2022, 9:49 PM
Jake-Egan updated this revision to Diff 436130.Jun 11 2022, 5:36 AM
This comment was removed by Jake-Egan.
Herald added a project: Restricted Project. · View Herald TranscriptJun 11 2022, 5:36 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Harbormaster completed remote builds in B169232: Diff 436130.Jun 11 2022, 6:50 AM
daltenty added inline comments.Jun 13 2022, 7:23 AM
libcxx/CMakeLists.txt
472

Would setting this in our AIX CMake cache file be sufficient? That might be preferable to hardcoding part of the tool chain in each of the top-level CMake files.

ldionne accepted this revision.Jun 13 2022, 7:53 AM
ldionne added a subscriber: ldionne.

LGTM with comments addressed.

libcxx/CMakeLists.txt
472

Yes, please do it in the CMake cache instead to avoid adding platform-specific code to the CMakeLists.txt.

libcxxabi/CMakeLists.txt
232

Same comment here.

libunwind/CMakeLists.txt
146 ↗(On Diff #436130)

And here.

This revision is now accepted and ready to land.Jun 13 2022, 7:53 AM
Jake-Egan updated this revision to Diff 436424.Jun 13 2022, 8:45 AM

Use CMake cache to set ar path instead.

Jake-Egan marked 3 inline comments as done.Jun 13 2022, 8:47 AM
daltenty accepted this revision.Jun 13 2022, 10:04 AM

LGTM, with minor nit

libcxx/include/__config
131

nit: It's probably worth a comment to explain this:

daltenty edited the summary of this revision. (Show Details)Jun 13 2022, 10:06 AM
Jake-Egan updated this revision to Diff 436459.Jun 13 2022, 10:11 AM

Added requested comment.

Jake-Egan marked an inline comment as done.Jun 13 2022, 10:41 AM
Harbormaster completed remote builds in B169493: Diff 436459.Jun 13 2022, 2:04 PM
Jake-Egan updated this revision to Diff 436571.Jun 13 2022, 2:38 PM

Add CACHE FILEPATH to CMAKE_AR.

Harbormaster completed remote builds in B169568: Diff 436571.Jun 13 2022, 6:39 PM
Closed by commit rG1cf4113952ae: [libcxx][AIX] Switch build compiler to clang (authored by Jake-Egan). · Explain WhyJun 13 2022, 6:45 PM
This revision was automatically updated to reflect the committed changes.
Jake-Egan added a commit: rG1cf4113952ae: [libcxx][AIX] Switch build compiler to clang.

Revision Contents

PathSize
libcxx/
5 lines
cmake/
caches/
1 line
include/
4 lines
test/
configs/
2 lines
std/
strings/
basic.string/
string.access/
2 lines
2 lines
2 lines
2 lines
string.capacity/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.cons/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.iterators/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.modifiers/
string_append/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string_assign/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string_copy/
2 lines
string_erase/
2 lines
2 lines
2 lines
2 lines
string_insert/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string_op_plus_equal/
2 lines
2 lines
2 lines
2 lines
string_replace/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string_swap/
2 lines
string.nonmembers/
string.special/
2 lines
string_op!=/
2 lines
2 lines
2 lines
2 lines
2 lines
string_op+/
2 lines
2 lines
2 lines
2 lines
2 lines
string_operator==/
2 lines
2 lines
2 lines
2 lines
2 lines
string_opgt/
2 lines
2 lines
2 lines
2 lines
2 lines
string_opgt=/
2 lines
2 lines
2 lines
2 lines
2 lines
string_oplt/
2 lines
2 lines
2 lines
2 lines
2 lines
string_oplt=/
2 lines
2 lines
2 lines
2 lines
2 lines
string.ops/
string.accessors/
2 lines
2 lines
2 lines
string_compare/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string_find.first.not.of/
2 lines
2 lines
2 lines
2 lines
2 lines
string_find.first.of/
2 lines
2 lines
2 lines
2 lines
2 lines
string_find.last.not.of/
2 lines
2 lines
2 lines
2 lines
2 lines
string_find.last.of/
2 lines
2 lines
2 lines
2 lines
2 lines
string_find/
2 lines
2 lines
2 lines
2 lines
2 lines
string_rfind/
2 lines
2 lines
2 lines
2 lines
2 lines
string_substr/
2 lines
string.require/
2 lines
utils/
ci/
4 lines
libcxxabi/
5 lines
test/
configs/
2 lines

Diff 436424

libcxx/CMakeLists.txt

Show First 20 Lines • Show All 463 Lines • ▼ Show 20 Lines
# LIBCXX_COMPILE_FLAGS: Compile only flags. # LIBCXX_COMPILE_FLAGS: Compile only flags.
# LIBCXX_LINK_FLAGS: Linker only flags. # LIBCXX_LINK_FLAGS: Linker only flags.
# LIBCXX_LIBRARIES: libraries libc++ is linked to. # LIBCXX_LIBRARIES: libraries libc++ is linked to.
set(LIBCXX_COMPILE_FLAGS "") set(LIBCXX_COMPILE_FLAGS "")
set(LIBCXX_LINK_FLAGS "") set(LIBCXX_LINK_FLAGS "")
set(LIBCXX_LIBRARIES "") set(LIBCXX_LIBRARIES "")
# Include macros for adding and removing libc++ flags. # Include macros for adding and removing libc++ flags.
include(HandleLibcxxFlags) include(HandleLibcxxFlags)
daltentyUnsubmitted
Done
ReplyInline Actions

Would setting this in our AIX CMake cache file be sufficient? That might be preferable to hardcoding part of the tool chain in each of the top-level CMake files.

daltenty: Would setting this in our AIX CMake cache file be sufficient? That might be preferable to…
ldionneUnsubmitted
Done
ReplyInline Actions

Yes, please do it in the CMake cache instead to avoid adding platform-specific code to the CMakeLists.txt.

ldionne: Yes, please do it in the CMake cache instead to avoid adding platform-specific code to the…
# Target flags ================================================================ # Target flags ================================================================
# These flags get added to CMAKE_CXX_FLAGS and CMAKE_C_FLAGS so that # These flags get added to CMAKE_CXX_FLAGS and CMAKE_C_FLAGS so that
# 'config-ix' use them during feature checks. It also adds them to both # 'config-ix' use them during feature checks. It also adds them to both
# 'LIBCXX_COMPILE_FLAGS' and 'LIBCXX_LINK_FLAGS' # 'LIBCXX_COMPILE_FLAGS' and 'LIBCXX_LINK_FLAGS'
if(ZOS) if(ZOS)
add_target_flags_if_supported("-fzos-le-char-mode=ebcdic") add_target_flags_if_supported("-fzos-le-char-mode=ebcdic")
endif() endif()
if (${CMAKE_SYSTEM_NAME} MATCHES "AIX")
add_target_flags_if_supported("-mdefault-visibility-export-mapping=explicit")
set(CMAKE_AIX_EXPORT_ALL_SYMBOLS OFF)
endif()
# Configure compiler. # Configure compiler.
include(config-ix) include(config-ix)
# Configure coverage options. # Configure coverage options.
if (LIBCXX_GENERATE_COVERAGE) if (LIBCXX_GENERATE_COVERAGE)
include(CodeCoverage) include(CodeCoverage)
set(CMAKE_BUILD_TYPE "COVERAGE" CACHE STRING "" FORCE) set(CMAKE_BUILD_TYPE "COVERAGE" CACHE STRING "" FORCE)
endif() endif()
▲ Show 20 Lines • Show All 462 Lines • Show Last 20 Lines

libcxx/cmake/caches/AIX.cmake

set(CMAKE_BUILD_TYPE Release CACHE STRING "") set(CMAKE_BUILD_TYPE Release CACHE STRING "")
set(CMAKE_BUILD_WITH_INSTALL_RPATH ON CACHE BOOL "") set(CMAKE_BUILD_WITH_INSTALL_RPATH ON CACHE BOOL "")
set(CMAKE_C_FLAGS "-D__LIBC_NO_CPP_MATH_OVERLOADS__" CACHE STRING "") set(CMAKE_C_FLAGS "-D__LIBC_NO_CPP_MATH_OVERLOADS__" CACHE STRING "")
set(CMAKE_CXX_FLAGS "-D__LIBC_NO_CPP_MATH_OVERLOADS__" CACHE STRING "") set(CMAKE_CXX_FLAGS "-D__LIBC_NO_CPP_MATH_OVERLOADS__" CACHE STRING "")
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,-G -Wl,-bcdtors:all:-2147483548:s" CACHE STRING "") set(CMAKE_SHARED_LINKER_FLAGS "-Wl,-G -Wl,-bcdtors:all:-2147483548:s" CACHE STRING "")
set(CMAKE_AR "/usr/bin/ar")
set(LIBCXX_USE_COMPILER_RT ON CACHE BOOL "") set(LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
set(LIBCXX_ENABLE_ASSERTIONS OFF CACHE BOOL "") set(LIBCXX_ENABLE_ASSERTIONS OFF CACHE BOOL "")
set(LIBCXX_ABI_VERSION "1" CACHE STRING "") set(LIBCXX_ABI_VERSION "1" CACHE STRING "")
set(LIBCXX_ENABLE_ABI_LINKER_SCRIPT OFF CACHE BOOL "") set(LIBCXX_ENABLE_ABI_LINKER_SCRIPT OFF CACHE BOOL "")
set(LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY OFF CACHE BOOL "") set(LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY OFF CACHE BOOL "")
set(LIBCXX_ENABLE_SHARED ON CACHE BOOL "") set(LIBCXX_ENABLE_SHARED ON CACHE BOOL "")
set(LIBCXX_ENABLE_STATIC OFF CACHE BOOL "") set(LIBCXX_ENABLE_STATIC OFF CACHE BOOL "")
set(LIBCXXABI_ENABLE_SHARED ON CACHE BOOL "") set(LIBCXXABI_ENABLE_SHARED ON CACHE BOOL "")
set(LIBCXXABI_ENABLE_STATIC OFF CACHE BOOL "") set(LIBCXXABI_ENABLE_STATIC OFF CACHE BOOL "")
set(LIBCXX_CXX_ABI libcxxabi CACHE STRING "") set(LIBCXX_CXX_ABI libcxxabi CACHE STRING "")
set(LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "") set(LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
set(LIBUNWIND_ENABLE_SHARED ON CACHE BOOL "") set(LIBUNWIND_ENABLE_SHARED ON CACHE BOOL "")
set(LIBUNWIND_ENABLE_STATIC OFF CACHE BOOL "") set(LIBUNWIND_ENABLE_STATIC OFF CACHE BOOL "")

libcxx/include/__config

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
#if defined(__ELF__) #if defined(__ELF__)
# define _LIBCPP_OBJECT_FORMAT_ELF 1 # define _LIBCPP_OBJECT_FORMAT_ELF 1
#elif defined(__MACH__) #elif defined(__MACH__)
# define _LIBCPP_OBJECT_FORMAT_MACHO 1 # define _LIBCPP_OBJECT_FORMAT_MACHO 1
#elif defined(_WIN32) #elif defined(_WIN32)
# define _LIBCPP_OBJECT_FORMAT_COFF 1 # define _LIBCPP_OBJECT_FORMAT_COFF 1
#elif defined(__wasm__) #elif defined(__wasm__)
# define _LIBCPP_OBJECT_FORMAT_WASM 1 # define _LIBCPP_OBJECT_FORMAT_WASM 1
#elif defined(_AIX)
# define _LIBCPP_OBJECT_FORMAT_XCOFF 1
#else #else
// ... add new file formats here ... // ... add new file formats here ...
#endif #endif
#if _LIBCPP_ABI_VERSION >= 2 #if _LIBCPP_ABI_VERSION >= 2
// Change short string representation so that string data starts at offset 0, // Change short string representation so that string data starts at offset 0,
// improving its alignment in some cases. // improving its alignment in some cases.
# define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT # define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
# define _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON # define _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON
// According to the Standard, `bitset::operator[] const` returns bool // According to the Standard, `bitset::operator[] const` returns bool
# define _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL # define _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
// Remove the base 10 implementation of std::to_chars from the dylib. // Remove the base 10 implementation of std::to_chars from the dylib.
// The implementation moved to the header, but we still export the symbols from // The implementation moved to the header, but we still export the symbols from
// the dylib for backwards compatibility. // the dylib for backwards compatibility.
# define _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10 # define _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
#elif _LIBCPP_ABI_VERSION == 1 #elif _LIBCPP_ABI_VERSION == 1
# if !defined(_LIBCPP_OBJECT_FORMAT_COFF) # if !(defined(_LIBCPP_OBJECT_FORMAT_COFF)||defined(_LIBCPP_OBJECT_FORMAT_XCOFF))
// Enable compiling copies of now inline methods into the dylib to support // Enable compiling copies of now inline methods into the dylib to support
// applications compiled against older libraries. This is unnecessary with // applications compiled against older libraries. This is unnecessary with
// COFF dllexport semantics, since dllexport forces a non-inline definition // COFF dllexport semantics, since dllexport forces a non-inline definition
// of inline functions to be emitted anyway. Our own non-inline copy would // of inline functions to be emitted anyway. Our own non-inline copy would
// conflict with the dllexport-emitted copy, so we disable it. // conflict with the dllexport-emitted copy, so we disable it.
daltentyUnsubmitted
Done
ReplyInline Actions
// of inline functions to be emitted anyway. Our own non-inline copy would
- // conflict with the dllexport-emitted copy, so we disable it.
+ // conflict with the dllexport-emitted copy, so we disable it. For XCOFF,
+ // the linker will take issue with the symbols in the shared object if the
+ // weak inline methods get visibility (such as from -fvisibility-inlines-hidden),
+ // so disable it.
# define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS

nit: It's probably worth a comment to explain this:

daltenty: nit: It's probably worth a comment to explain this:
# define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS # define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
# endif # endif
// Feature macros for disabling pre ABI v1 features. All of these options // Feature macros for disabling pre ABI v1 features. All of these options
// are deprecated. // are deprecated.
# if defined(__FreeBSD__) # if defined(__FreeBSD__)
# define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR # define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
# endif # endif
#endif #endif
▲ Show 20 Lines • Show All 1,153 Lines • Show Last 20 Lines

libcxx/test/configs/ibm-libc++-shared.cfg.in

# This testing configuration handles running the test suite against libc++ on # This testing configuration handles running the test suite against libc++ on
# AIX using a shared library. # AIX using a shared library.
# #
lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg') lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg')
config.substitutions.append(('%{flags}', '')) config.substitutions.append(('%{flags}', ''))
config.substitutions.append(('%{compile_flags}', config.substitutions.append(('%{compile_flags}',
'-nostdinc++ -D__LIBC_NO_CPP_MATH_OVERLOADS__ -I %{include} -I %{libcxx}/test/support' '-nostdinc++ -D__LIBC_NO_CPP_MATH_OVERLOADS__ -I %{include} -I %{libcxx}/test/support -pthread'
)) ))
config.substitutions.append(('%{link_flags}', config.substitutions.append(('%{link_flags}',
'-nostdlib++ -L %{lib} -lc++ -lc++abi -latomic -Wl,-bbigtoc' '-nostdlib++ -L %{lib} -lc++ -lc++abi -latomic -Wl,-bbigtoc'
)) ))
config.substitutions.append(('%{exec}', config.substitutions.append(('%{exec}',
'%{executor} --execdir %T --env LIBPATH=%{lib} -- ' '%{executor} --execdir %T --env LIBPATH=%{lib} -- '
)) ))
Show All 16 Lines

libcxx/test/std/strings/basic.string/string.access/at.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const_reference at(size_type pos) const; // constexpr since C++20 // const_reference at(size_type pos) const; // constexpr since C++20
// reference at(size_type pos); // constexpr since C++20 // reference at(size_type pos); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.access/back.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const charT& back() const; // constexpr since C++20 // const charT& back() const; // constexpr since C++20
// charT& back(); // constexpr since C++20 // charT& back(); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.access/front.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const charT& front() const; // constexpr since C++20 // const charT& front() const; // constexpr since C++20
// charT& front(); // constexpr since C++20 // charT& front(); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.access/index.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const_reference operator[](size_type pos) const; // constexpr since C++20 // const_reference operator[](size_type pos) const; // constexpr since C++20
// reference operator[](size_type pos); // constexpr since C++20 // reference operator[](size_type pos); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// void clear(); // constexpr since C++20 // void clear(); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// bool empty() const noexcept; // constexpr since C++20 // bool empty() const noexcept; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 38 Lines

libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type length() const; // constexpr since C++20 // size_type length() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 37 Lines

libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// void reserve(size_type res_arg); // constexpr since C++20 // void reserve(size_type res_arg); // constexpr since C++20
// This test relies on https://llvm.org/PR45368 being fixed, which isn't in // This test relies on https://llvm.org/PR45368 being fixed, which isn't in
// older Apple dylibs // older Apple dylibs
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0}}
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// void resize(size_type n); // constexpr since C++20 // void resize(size_type n); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// void resize(size_type n, charT c); // constexpr since C++20 // void resize(size_type n, charT c); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// void shrink_to_fit(); // constexpr since C++20 // void shrink_to_fit(); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type size() const; // constexpr since C++20 // size_type size() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 37 Lines

libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class _Tp> // template<class _Tp>
// basic_string(const _Tp& __t, size_type __pos, size_type __n, // basic_string(const _Tp& __t, size_type __pos, size_type __n,
// const allocator_type& __a = allocator_type()); // constexpr since C++20 // const allocator_type& __a = allocator_type()); // constexpr since C++20
// //
// Mostly we're testing string_view here // Mostly we're testing string_view here
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& operator=(charT c); // constexpr since C++20 // basic_string<charT,traits,Allocator>& operator=(charT c); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20 // basic_string(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string(const basic_string& str, const Allocator& alloc); // constexpr since C++20 // basic_string(const basic_string& str, const Allocator& alloc); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// operator=(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20 // operator=(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string(initializer_list<charT> il, const Allocator& a = Allocator()); // constexpr since C++20 // basic_string(initializer_list<charT> il, const Allocator& a = Allocator()); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class InputIterator> // template<class InputIterator>
// basic_string(InputIterator begin, InputIterator end, // basic_string(InputIterator begin, InputIterator end,
// const Allocator& a = Allocator()); // constexpr since C++20 // const Allocator& a = Allocator()); // constexpr since C++20
#include <string> #include <string>
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// XFAIL: LIBCXX-AIX-FIXME
// template<class InputIterator, // template<class InputIterator,
// class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> // class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
// basic_string(InputIterator, InputIterator, Allocator = Allocator()) // basic_string(InputIterator, InputIterator, Allocator = Allocator())
// -> basic_string<typename iterator_traits<InputIterator>::value_type, // -> basic_string<typename iterator_traits<InputIterator>::value_type,
// char_traits<typename iterator_traits<InputIterator>::value_type>, // char_traits<typename iterator_traits<InputIterator>::value_type>,
// Allocator>; // constexpr since C++20 // Allocator>; // constexpr since C++20
// //
// The deduction guide shall not participate in overload resolution if InputIterator // The deduction guide shall not participate in overload resolution if InputIterator
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string(basic_string<charT,traits,Allocator>&& str); // constexpr since C++20 // basic_string(basic_string<charT,traits,Allocator>&& str); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string(basic_string&& str, const Allocator& alloc); // constexpr since C++20 // basic_string(basic_string&& str, const Allocator& alloc); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// operator=(basic_string<charT,traits,Allocator>&& str); // constexpr since C++20 // operator=(basic_string<charT,traits,Allocator>&& str); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// XFAIL: LIBCXX-AIX-FIXME
// basic_string(const charT* s, const Allocator& a = Allocator()); // constexpr since C++20 // basic_string(const charT* s, const Allocator& a = Allocator()); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// operator=(const charT* s); // constexpr since C++20 // operator=(const charT* s); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string(const charT* s, size_type n, const Allocator& a = Allocator()); // constexpr since C++20 // basic_string(const charT* s, size_type n, const Allocator& a = Allocator()); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string(size_type n, charT c, const Allocator& a = Allocator()); // constexpr since C++20 // basic_string(size_type n, charT c, const Allocator& a = Allocator()); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// explicit basic_string(basic_string_view<CharT, traits> sv, const Allocator& a = Allocator()); // constexpr since C++20 // explicit basic_string(basic_string_view<CharT, traits> sv, const Allocator& a = Allocator()); // constexpr since C++20
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <stdexcept> #include <stdexcept>
#include <string_view> #include <string_view>
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& operator=(basic_string_view<charT, traits> sv); // constexpr since C++20 // basic_string<charT,traits,Allocator>& operator=(basic_string_view<charT, traits> sv); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// template<class charT, // template<class charT,
// class traits, // class traits,
// class Allocator = allocator<charT> // class Allocator = allocator<charT>
// > // >
// basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator()) // basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// template<class charT, // template<class charT,
// class traits, // class traits,
// class Allocator = allocator<charT> // class Allocator = allocator<charT>
// > // >
// basic_string(basic_string_view<charT, traits>, // basic_string(basic_string_view<charT, traits>,
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string(const basic_string<charT,traits,Allocator>& str, // basic_string(const basic_string<charT,traits,Allocator>& str,
// size_type pos, size_type n, // size_type pos, size_type n,
// const Allocator& a = Allocator()); // constexpr since C++20 // const Allocator& a = Allocator()); // constexpr since C++20
// //
// basic_string(const basic_string<charT,traits,Allocator>& str, // basic_string(const basic_string<charT,traits,Allocator>& str,
// size_type pos, // size_type pos,
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// iterator begin(); // constexpr since C++20 // iterator begin(); // constexpr since C++20
// const_iterator begin() const; // constexpr since C++20 // const_iterator begin() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const_iterator cbegin() const; // constexpr since C++20 // const_iterator cbegin() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 40 Lines

libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const_iterator cend() const; // constexpr since C++20 // const_iterator cend() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 35 Lines

libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const_reverse_iterator crbegin() const; // constexpr since C++20 // const_reverse_iterator crbegin() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 40 Lines

libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const_reverse_iterator crend() const; // constexpr since C++20 // const_reverse_iterator crend() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 36 Lines

libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// iterator end(); // constexpr since C++20 // iterator end(); // constexpr since C++20
// const_iterator end() const; // constexpr since C++20 // const_iterator end() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// reverse_iterator rbegin(); // constexpr since C++20 // reverse_iterator rbegin(); // constexpr since C++20
// const_reverse_iterator rbegin() const; // constexpr since C++20 // const_reverse_iterator rbegin() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// reverse_iterator rend(); // constexpr since C++20 // reverse_iterator rend(); // constexpr since C++20
// const_reverse_iterator rend() const; // constexpr since C++20 // const_reverse_iterator rend() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template <class T> // template <class T>
// basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17, constexpr since C++20 // basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17, constexpr since C++20
#include <string> #include <string>
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <string> // <string>
// basic_string& append(initializer_list<charT> il); // constexpr since C++20 // basic_string& append(initializer_list<charT> il); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
Show All 29 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class InputIterator> // template<class InputIterator>
// basic_string& append(InputIterator first, InputIterator last); // constexpr since C++20 // basic_string& append(InputIterator first, InputIterator last); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 250 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& append(const charT* s); // constexpr since C++20 // basic_string<charT,traits,Allocator>& append(const charT* s); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// append(const charT* s, size_type n); // constexpr since C++20 // append(const charT* s, size_type n); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// void push_back(charT c) // constexpr since C++20 // void push_back(charT c) // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// append(size_type n, charT c); // constexpr since C++20 // append(size_type n, charT c); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// append(const basic_string<charT,traits>& str); // constexpr since C++20 // append(const basic_string<charT,traits>& str); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// append(const basic_string<charT,traits>& str, size_type pos, size_type n = npos); // constexpr since C++20 // append(const basic_string<charT,traits>& str, size_type pos, size_type n = npos); // constexpr since C++20
// the "= npos" was added for C++14 // the "= npos" was added for C++14
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// append(basic_string_view<charT,traits> sv); // constexpr since C++20 // append(basic_string_view<charT,traits> sv); // constexpr since C++20
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template <class T> // template <class T>
// basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17, constexpr since C++20 // basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17, constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <string> // <string>
// basic_string& assign(initializer_list<charT> il); // constexpr since C++20 // basic_string& assign(initializer_list<charT> il); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
Show All 29 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class InputIterator> // template<class InputIterator>
// basic_string& assign(InputIterator first, InputIterator last); // constexpr since C++20 // basic_string& assign(InputIterator first, InputIterator last); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& assign(const charT* s); // constexpr since C++20 // basic_string<charT,traits,Allocator>& assign(const charT* s); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// assign(const charT* s, size_type n); // constexpr since C++20 // assign(const charT* s, size_type n); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// assign(basic_string<charT,traits>&& str); // constexpr since C++20 // assign(basic_string<charT,traits>&& str); // constexpr since C++20
#include <string> #include <string>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// assign(size_type n, charT c); // constexpr since C++20 // assign(size_type n, charT c); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// assign(const basic_string<charT,traits>& str); // constexpr since C++20 // assign(const basic_string<charT,traits>& str); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// assign(const basic_string<charT,traits>& str, size_type pos, size_type n=npos); // constexpr since C++20 // assign(const basic_string<charT,traits>& str, size_type pos, size_type n=npos); // constexpr since C++20
// the =npos was added for C++14 // the =npos was added for C++14
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// assign(basic_string_view<charT,traits> sv); // constexpr since C++20 // assign(basic_string_view<charT,traits> sv); // constexpr since C++20
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type copy(charT* s, size_type n, size_type pos = 0) const; // constexpr since C++20 // size_type copy(charT* s, size_type n, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// iterator erase(const_iterator p); // constexpr since C++20 // iterator erase(const_iterator p); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// iterator erase(const_iterator first, const_iterator last); // constexpr since C++20 // iterator erase(const_iterator first, const_iterator last); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// void pop_back(); // constexpr since C++20 // void pop_back(); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 40 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// erase(size_type pos = 0, size_type n = npos); // constexpr since C++20 // erase(size_type pos = 0, size_type n = npos); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 296 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// iterator insert(const_iterator p, charT c); // constexpr since C++20 // iterator insert(const_iterator p, charT c); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// iterator insert(const_iterator p, initializer_list<charT> il); // constexpr since C++20 // iterator insert(const_iterator p, initializer_list<charT> il); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
Show All 30 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class InputIterator> // template<class InputIterator>
// iterator insert(const_iterator p, InputIterator first, InputIterator last); // constexpr since C++20 // iterator insert(const_iterator p, InputIterator first, InputIterator last); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// iterator insert(const_iterator p, size_type n, charT c); // constexpr since C++20 // iterator insert(const_iterator p, size_type n, charT c); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template <class T> // template <class T>
// basic_string& assign(size_type pos1, const T& t, size_type pos2, size_type n=npos); // C++17, constexpr since C++20 // basic_string& assign(size_type pos1, const T& t, size_type pos2, size_type n=npos); // C++17, constexpr since C++20
// //
// Mostly we're testing string_view here // Mostly we're testing string_view here
#include <string> #include <string>
▲ Show 20 Lines • Show All 1,895 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// insert(size_type pos, const charT* s); // constexpr since C++20 // insert(size_type pos, const charT* s); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// insert(size_type pos, const charT* s, size_type n); // constexpr since C++20 // insert(size_type pos, const charT* s, size_type n); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 391 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// insert(size_type pos, size_type n, charT c); // constexpr since C++20 // insert(size_type pos, size_type n, charT c); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// insert(size_type pos1, const basic_string& str); // constexpr since C++20 // insert(size_type pos1, const basic_string& str); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// insert(size_type pos1, const basic_string<charT,traits,Allocator>& str, // insert(size_type pos1, const basic_string<charT,traits,Allocator>& str,
// size_type pos2, size_type n=npos); // constexpr since C++20 // size_type pos2, size_type n=npos); // constexpr since C++20
// the "=npos" was added in C++14 // the "=npos" was added in C++14
#include <string> #include <string>
▲ Show 20 Lines • Show All 1,853 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// insert(size_type pos, string_view sv); // constexpr since C++20 // insert(size_type pos, string_view sv); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& operator+=(charT c); // constexpr since C++20 // basic_string<charT,traits,Allocator>& operator+=(charT c); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <string> // <string>
// basic_string& operator+=(initializer_list<charT> il); // constexpr since C++20 // basic_string& operator+=(initializer_list<charT> il); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
Show All 29 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& operator+=(const charT* s); // constexpr since C++20 // basic_string<charT,traits,Allocator>& operator+=(const charT* s); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// operator+=(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20 // operator+=(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <string> // <string>
// basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il); // constexpr since C++20 // basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
Show All 29 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class InputIterator> // template<class InputIterator>
// basic_string& // basic_string&
// replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); // constexpr since C++20 // replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); // constexpr since C++20
#include <string> #include <string>
#include <iterator> #include <iterator>
▲ Show 20 Lines • Show All 1,065 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(const_iterator i1, const_iterator i2, const charT* s); // constexpr since C++20 // replace(const_iterator i1, const_iterator i2, const charT* s); // constexpr since C++20
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
▲ Show 20 Lines • Show All 306 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(const_iterator i1, const_iterator i2, const charT* s, size_type n); // constexpr since C++20 // replace(const_iterator i1, const_iterator i2, const charT* s, size_type n); // constexpr since C++20
#include <string> #include <string>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 1,001 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(const_iterator i1, const_iterator i2, size_type n, charT c); // constexpr since C++20 // replace(const_iterator i1, const_iterator i2, size_type n, charT c); // constexpr since C++20
#include <string> #include <string>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(const_iterator i1, const_iterator i2, const basic_string& str); // constexpr since C++20 // replace(const_iterator i1, const_iterator i2, const basic_string& str); // constexpr since C++20
#include <string> #include <string>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(const_iterator i1, const_iterator i2, basic_string_view<charT,traits> sv); // constexpr since C++20 // replace(const_iterator i1, const_iterator i2, basic_string_view<charT,traits> sv); // constexpr since C++20
#include <string> #include <string>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 291 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template <class T> // template <class T>
// basic_string& replace(size_type pos1, size_type n1, const T& t, // basic_string& replace(size_type pos1, size_type n1, const T& t,
// size_type pos2, size_type n=npos); // constexpr since C++20 // size_type pos2, size_type n=npos); // constexpr since C++20
// //
// Mostly we're testing string_view here // Mostly we're testing string_view here
▲ Show 20 Lines • Show All 6,133 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(size_type pos, size_type n1, const charT* s); // constexpr since C++20 // replace(size_type pos, size_type n1, const charT* s); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
▲ Show 20 Lines • Show All 378 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(size_type pos, size_type n1, const charT* s, size_type n2); // constexpr since C++20 // replace(size_type pos, size_type n1, const charT* s, size_type n2); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
▲ Show 20 Lines • Show All 1,347 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(size_type pos, size_type n1, size_type n2, charT c); // constexpr since C++20 // replace(size_type pos, size_type n1, size_type n2, charT c); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
▲ Show 20 Lines • Show All 378 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(size_type pos1, size_type n1, const basic_string<charT,traits,Allocator>& str); // constexpr since C++20 // replace(size_type pos1, size_type n1, const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
▲ Show 20 Lines • Show All 385 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(size_type pos1, size_type n1, const basic_string<charT,traits,Allocator>& str, // replace(size_type pos1, size_type n1, const basic_string<charT,traits,Allocator>& str,
// size_type pos2, size_type n2=npos); // constexpr since C++20 // size_type pos2, size_type n2=npos); // constexpr since C++20
// the "=npos" was added in C++14 // the "=npos" was added in C++14
#include <string> #include <string>
▲ Show 20 Lines • Show All 6,085 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string<charT,traits,Allocator>& // basic_string<charT,traits,Allocator>&
// replace(size_type pos1, size_type n1, basic_string_view<charT,traits> sv); // constexpr since C++20 // replace(size_type pos1, size_type n1, basic_string_view<charT,traits> sv); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
▲ Show 20 Lines • Show All 378 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// void swap(basic_string& s); // constexpr since C++20 // void swap(basic_string& s); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// void swap(basic_string<charT,traits,Allocator>& lhs, // void swap(basic_string<charT,traits,Allocator>& lhs,
// basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator!=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // bool operator!=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator!=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20 // bool operator!=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator!=(const basic_string<charT,traits,Allocator>& lhs, // bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
// const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator> // basic_string<charT,traits,Allocator>
// operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator>&& // basic_string<charT,traits,Allocator>&&
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator> // basic_string<charT,traits,Allocator>
// operator+(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // operator+(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator>&& // basic_string<charT,traits,Allocator>&&
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator> // basic_string<charT,traits,Allocator>
// operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs); // constexpr since C++20 // operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs); // constexpr since C++20
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator>&& // basic_string<charT,traits,Allocator>&&
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator> // basic_string<charT,traits,Allocator>
// operator+(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20 // operator+(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator>&& // basic_string<charT,traits,Allocator>&&
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_string<charT,traits,Allocator> // basic_string<charT,traits,Allocator>
// operator+(const basic_string<charT,traits,Allocator>& lhs, // operator+(const basic_string<charT,traits,Allocator>& lhs,
// const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator==(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // bool operator==(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20 // bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator==(const basic_string<charT,traits,Allocator>& lhs, // bool operator==(const basic_string<charT,traits,Allocator>& lhs,
// const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator>(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // bool operator>(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator>(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20 // bool operator>(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator>(const basic_string<charT,traits,Allocator>& lhs, // bool operator>(const basic_string<charT,traits,Allocator>& lhs,
// const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator>=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // bool operator>=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator>=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20 // bool operator>=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator>=(const basic_string<charT,traits,Allocator>& lhs, // bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
// const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator<(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // bool operator<(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator<(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20 // bool operator<(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator<(const basic_string<charT,traits,Allocator>& lhs, // bool operator<(const basic_string<charT,traits,Allocator>& lhs,
// const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator<=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // bool operator<=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator<=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20 // bool operator<=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator<=(const basic_string<charT,traits,Allocator>& lhs, // bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
// const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20 // const basic_string<charT,traits,Allocator>& rhs); // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// we get this comparison "for free" because the string implicitly converts to the string_view // we get this comparison "for free" because the string implicitly converts to the string_view
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const charT* c_str() const; // constexpr since C++20 // const charT* c_str() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// const charT* data() const; // constexpr since C++20 // const charT* data() const; // constexpr since C++20
// charT* data(); // C++17, constexpr since C++20 // charT* data(); // C++17, constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// allocator_type get_allocator() const; // constexpr since C++20 // allocator_type get_allocator() const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// int compare(const charT *s) const; // constexpr since C++20 // int compare(const charT *s) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// template <typename T> // template <typename T>
// int compare(size_type pos1, size_type n1, const T& t, // int compare(size_type pos1, size_type n1, const T& t,
// size_type pos2, size_type n2=npos) const; // constexpr since C++20 // size_type pos2, size_type n2=npos) const; // constexpr since C++20
// //
// Mostly we're testing string_view here // Mostly we're testing string_view here
▲ Show 20 Lines • Show All 6,096 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// int compare(size_type pos, size_type n1, const charT *s) const; // constexpr since C++20 // int compare(size_type pos, size_type n1, const charT *s) const; // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 375 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// int compare(size_type pos, size_type n1, const charT *s, size_type n2) const; // constexpr since C++20 // int compare(size_type pos, size_type n1, const charT *s, size_type n2) const; // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 1,344 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// int compare(size_type pos1, size_type n1, const basic_string& str) const; // constexpr since C++20 // int compare(size_type pos1, size_type n1, const basic_string& str) const; // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 381 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// int compare(size_type pos1, size_type n1, const basic_string& str, // int compare(size_type pos1, size_type n1, const basic_string& str,
// size_type pos2, size_type n2=npos) const; // constexpr since C++20 // size_type pos2, size_type n2=npos) const; // constexpr since C++20
// the "=npos" was added in C++14 // the "=npos" was added in C++14
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
▲ Show 20 Lines • Show All 6,062 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// int compare(size_type pos1, size_type n1, basic_string_view sv) const; // constexpr since C++20 // int compare(size_type pos1, size_type n1, basic_string_view sv) const; // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 377 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// int compare(const basic_string& str) const // constexpr since C++20 // int compare(const basic_string& str) const // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// int compare(const basic_string_view sv) const // constexpr since C++20 // int compare(const basic_string_view sv) const // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_not_of(charT c, size_type pos = 0) const; // constexpr since C++20 // size_type find_first_not_of(charT c, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_not_of(const charT* s, size_type pos = 0) const; // constexpr since C++20 // size_type find_first_not_of(const charT* s, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_not_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20 // size_type find_first_not_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_not_of(const basic_string& str, size_type pos = 0) const; // constexpr since C++20 // size_type find_first_not_of(const basic_string& str, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_not_of(basic_string_view sv, size_type pos = 0) const; // constexpr since C++20 // size_type find_first_not_of(basic_string_view sv, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_of(charT c, size_type pos = 0) const; // constexpr since C++20 // size_type find_first_of(charT c, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_of(const charT* s, size_type pos = 0) const; // constexpr since C++20 // size_type find_first_of(const charT* s, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20 // size_type find_first_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_of(const basic_string& str, size_type pos = 0) const; // constexpr since C++20 // size_type find_first_of(const basic_string& str, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_first_of(const basic_string_view sv, size_type pos = 0) const; // constexpr since C++20 // size_type find_first_of(const basic_string_view sv, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_not_of(charT c, size_type pos = npos) const; // constexpr since C++20 // size_type find_last_not_of(charT c, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_not_of(const charT* s, size_type pos = npos) const; // constexpr since C++20 // size_type find_last_not_of(const charT* s, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_not_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20 // size_type find_last_not_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_not_of(const basic_string& str, size_type pos = npos) const; // constexpr since C++20 // size_type find_last_not_of(const basic_string& str, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_not_of(basic_string_view sv, size_type pos = npos) const; // constexpr since C++20 // size_type find_last_not_of(basic_string_view sv, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_of(charT c, size_type pos = npos) const; // constexpr since C++20 // size_type find_last_of(charT c, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_of(const charT* s, size_type pos = npos) const; // constexpr since C++20 // size_type find_last_of(const charT* s, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20 // size_type find_last_of(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_of(const basic_string& str, size_type pos = npos) const; // constexpr since C++20 // size_type find_last_of(const basic_string& str, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find_last_of(const basic_string_view sv, size_type pos = npos) const; // constexpr since C++20 // size_type find_last_of(const basic_string_view sv, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find(charT c, size_type pos = 0) const; // constexpr since C++20 // size_type find(charT c, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find(const charT* s, size_type pos = 0) const; // constexpr since C++20 // size_type find(const charT* s, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find(const charT* s, size_type pos, size_type n) const; // constexpr since C++20 // size_type find(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find(const basic_string& str, size_type pos = 0) const; // constexpr since C++20 // size_type find(const basic_string& str, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type find(basic_string_view sv, size_type pos = 0) const; // constexpr since C++20 // size_type find(basic_string_view sv, size_type pos = 0) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type rfind(charT c, size_type pos = npos) const; // constexpr since C++20 // size_type rfind(charT c, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type rfind(const charT* s, size_type pos = npos) const; // constexpr since C++20 // size_type rfind(const charT* s, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type rfind(const charT* s, size_type pos, size_type n) const; // constexpr since C++20 // size_type rfind(const charT* s, size_type pos, size_type n) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type rfind(const basic_string& str, size_type pos = npos) const; // constexpr since C++20 // size_type rfind(const basic_string& str, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// size_type rfind(basic_string_view sv, size_type pos = npos) const; // constexpr since C++20 // size_type rfind(basic_string_view sv, size_type pos = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <string> // <string>
// basic_string substr(size_type pos = 0, size_type n = npos) const; // constexpr since C++20 // basic_string substr(size_type pos = 0, size_type n = npos) const; // constexpr since C++20
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: LIBCXX-AIX-FIXME
// <array> // <array>
// An string is a contiguous container // An string is a contiguous container
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/utils/ci/run-buildbot

Show First 20 Lines • Show All 557 Lines • ▼ Show 20 Linesmingw-dll-i686)
generate-cmake \ generate-cmake \
-DCMAKE_C_COMPILER=i686-w64-mingw32-clang \ -DCMAKE_C_COMPILER=i686-w64-mingw32-clang \
-DCMAKE_CXX_COMPILER=i686-w64-mingw32-clang++ \ -DCMAKE_CXX_COMPILER=i686-w64-mingw32-clang++ \
-C "${MONOREPO_ROOT}/libcxx/cmake/caches/MinGW.cmake" -C "${MONOREPO_ROOT}/libcxx/cmake/caches/MinGW.cmake"
echo "+++ Running the libc++ tests" echo "+++ Running the libc++ tests"
${NINJA} -vC "${BUILD_DIR}" check-cxx ${NINJA} -vC "${BUILD_DIR}" check-cxx
;; ;;
aix) aix)
export CC=ibm-clang export CC=clang
export CXX=ibm-clang++_r export CXX=clang++
clean clean
generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/AIX.cmake" \ generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/AIX.cmake" \
-DLIBCXX_TEST_CONFIG="ibm-libc++-shared.cfg.in" \ -DLIBCXX_TEST_CONFIG="ibm-libc++-shared.cfg.in" \
-DLIBCXXABI_TEST_CONFIG="ibm-libc++abi-shared.cfg.in" \ -DLIBCXXABI_TEST_CONFIG="ibm-libc++abi-shared.cfg.in" \
-DLIBUNWIND_TEST_CONFIG="ibm-libunwind-shared.cfg.in" -DLIBUNWIND_TEST_CONFIG="ibm-libunwind-shared.cfg.in"
check-runtimes check-runtimes
;; ;;
################################################################# #################################################################
Show All 12 Lines

libcxxabi/CMakeLists.txt

Show First 20 Lines • Show All 223 Lines • ▼ Show 20 Lines
# LIBCXXABI_LIBRARIES: libraries libc++abi is linked to. # LIBCXXABI_LIBRARIES: libraries libc++abi is linked to.
set(LIBCXXABI_C_FLAGS "") set(LIBCXXABI_C_FLAGS "")
set(LIBCXXABI_CXX_FLAGS "") set(LIBCXXABI_CXX_FLAGS "")
set(LIBCXXABI_COMPILE_FLAGS "") set(LIBCXXABI_COMPILE_FLAGS "")
set(LIBCXXABI_LINK_FLAGS "") set(LIBCXXABI_LINK_FLAGS "")
set(LIBCXXABI_LIBRARIES "") set(LIBCXXABI_LIBRARIES "")
# Include macros for adding and removing libc++abi flags. # Include macros for adding and removing libc++abi flags.
ldionneUnsubmitted
Done
ReplyInline Actions

Same comment here.

ldionne: Same comment here.
include(HandleLibcxxabiFlags) include(HandleLibcxxabiFlags)
#=============================================================================== #===============================================================================
# Setup Compiler Flags # Setup Compiler Flags
#=============================================================================== #===============================================================================
# Configure target flags # Configure target flags
if(ZOS) if(ZOS)
add_target_flags_if_supported("-fzos-le-char-mode=ebcdic") add_target_flags_if_supported("-fzos-le-char-mode=ebcdic")
endif() endif()
if (${CMAKE_SYSTEM_NAME} MATCHES "AIX")
add_target_flags_if_supported("-mdefault-visibility-export-mapping=explicit")
set(CMAKE_AIX_EXPORT_ALL_SYMBOLS OFF)
endif()
# Configure compiler. Must happen after setting the target flags. # Configure compiler. Must happen after setting the target flags.
include(config-ix) include(config-ix)
if (CXX_SUPPORTS_NOSTDINCXX_FLAG) if (CXX_SUPPORTS_NOSTDINCXX_FLAG)
list(APPEND LIBCXXABI_COMPILE_FLAGS -nostdinc++) list(APPEND LIBCXXABI_COMPILE_FLAGS -nostdinc++)
# cmake 3.14 and above remove system include paths that are explicitly # cmake 3.14 and above remove system include paths that are explicitly
# passed on the command line. We build with -nostdinc++ and explicitly add # passed on the command line. We build with -nostdinc++ and explicitly add
# just the libcxx system include paths with -I on the command line. # just the libcxx system include paths with -I on the command line.
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

libcxxabi/test/configs/ibm-libc++abi-shared.cfg.in

# Testing configuration for libc++abi on AIX. # Testing configuration for libc++abi on AIX.
lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg') lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg')
config.substitutions.append(('%{flags}','')) config.substitutions.append(('%{flags}',''))
config.substitutions.append(('%{compile_flags}', config.substitutions.append(('%{compile_flags}',
'-nostdinc++ -I %{include} -I %{cxx-include} -I %{cxx-target-include} %{maybe-include-libunwind} ' + '-nostdinc++ -I %{include} -I %{cxx-include} -I %{cxx-target-include} %{maybe-include-libunwind} ' +
'-D__LIBC_NO_CPP_MATH_OVERLOADS__ ' + '-D__LIBC_NO_CPP_MATH_OVERLOADS__ ' +
'-D_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS ' + '-D_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS ' +
'-I %{libcxx}/test/support -I %{libcxx}/src' '-I %{libcxx}/test/support -pthread -I %{libcxx}/src'
)) ))
config.substitutions.append(('%{link_flags}', config.substitutions.append(('%{link_flags}',
'-nostdlib++ -L %{lib} -lc++ -lc++abi -Wl,-bbigtoc' '-nostdlib++ -L %{lib} -lc++ -lc++abi -Wl,-bbigtoc'
)) ))
config.substitutions.append(('%{exec}', config.substitutions.append(('%{exec}',
'%{executor} --execdir %T --env LIBPATH=%{lib} -- ' '%{executor} --execdir %T --env LIBPATH=%{lib} -- '
)) ))
Show All 9 Lines