This is an archive of the discontinued LLVM Phabricator instance.

Differential D126482

[runtimes] Rename various libcpp-has-no-XYZ Lit features to just no-XYZ
ClosedPublic

Authored by ldionne on May 26 2022, 8:51 AM.

Details

Reviewers
None
Group Reviewers
Restricted Project
Restricted Project
Commits
rGa7f9895cc189: [runtimes] Rename various libcpp-has-no-XYZ Lit features to just no-XYZ
Summary

Since those features are general properties of the environment, it makes
sense to use them from libc++abi too, and so the name libcpp-has-no-xxx
doesn't make sense.

Diff Detail

Event Timeline

ldionne created this revision.May 26 2022, 8:51 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 26 2022, 8:51 AM
Herald added a subscriber: arichardson. · View Herald Transcript
ldionne requested review of this revision.May 26 2022, 8:51 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptMay 26 2022, 8:51 AM
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
Harbormaster completed remote builds in B166489: Diff 432302.May 26 2022, 4:54 PM
ldionne accepted this revision as: Restricted Project, Restricted Project.May 27 2022, 12:23 PM
This revision was not accepted when it landed; it landed in state Needs Review.May 27 2022, 12:24 PM
Closed by commit rGa7f9895cc189: [runtimes] Rename various libcpp-has-no-XYZ Lit features to just no-XYZ (authored by ldionne). · Explain Why
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rGa7f9895cc189: [runtimes] Rename various libcpp-has-no-XYZ Lit features to just no-XYZ.

Revision Contents

PathSize
libcxx/
test/
libcxx/
atomics/
atomics.syn/
2 lines
stdatomic.h.syn/
2 lines
debug/
2 lines
2 lines
depr/
depr.c.headers/
2 lines
depr.str.strstreams/
2 lines
experimental/
memory/
memory.resource.aliases/
2 lines
fuzzing/
2 lines
gdb/
2 lines
inclusions/
2 lines
2 lines
2 lines
2 lines
2 lines
input.output/
filesystems/
class.path/
path.member/
path.native.obs/
2 lines
iostream.format/
input.streams/
2 lines
output.streams/
2 lines
string.streams/
2 lines
iterators/
iterator.requirements/
iterator.assoc.types/
iterator.traits/
2 lines
localization/
locales/
locale.convenience/
conversions/
conversions.string/
2 lines
2 lines
numerics/
rand/
rand.device/
2 lines
ranges/
2 lines
strings/
c.strings/
2 lines
2 lines
thread/
futures/
futures.promise/
2 lines
2 lines
futures.task/
2 lines
2 lines
thread.barrier/
2 lines
thread.condition/
2 lines
thread.condition.condvar/
2 lines
2 lines
thread.latch/
2 lines
thread.lock/
thread.lock.guard/
2 lines
thread.mutex/
thread.mutex.requirements/
thread.mutex.requirements.mutex/
thread.mutex.class/
2 lines
thread.mutex.recursive/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.semaphore/
2 lines
thread.threads/
2 lines
thread.thread.class/
thread.thread.member/
2 lines
2 lines
thread.thread.this/
2 lines
2 lines
2 lines
utilities/
memory/
util.smartptr/
2 lines
std/
atomics/
atomics.types.operations/
atomics.types.operations.wait/
2 lines
2 lines
2 lines
2 lines
stdatomic.h.syn/
2 lines
containers/
2 lines
depr/
depr.c.headers/
2 lines
2 lines
2 lines
depr.ios.members/
2 lines
depr.str.strstreams/
2 lines
diagnostics/
syserr/
syserr.errcode/
syserr.errcode.nonmembers/
2 lines
experimental/
iterator/
ostream.joiner/
ostream.joiner.cons/
2 lines
ostream.joiner.creation/
2 lines
ostream.joiner.ops/
2 lines
2 lines
2 lines
2 lines
memory/
memory.resource.aliases/
2 lines
input.output/
file.streams/
fstreams/
filebuf.members/
2 lines
fstream.cons/
2 lines
fstream.members/
2 lines
ifstream.cons/
2 lines
ifstream.members/
2 lines
ofstream.cons/
2 lines
ofstream.members/
2 lines
2 lines
filesystems/
class.directory_entry/
directory_entry.io/
2 lines
class.path/
path.member/
2 lines
path.assign/
2 lines
2 lines
2 lines
path.construct/
2 lines
path.generic.obs/
2 lines
2 lines
path.native.obs/
2 lines
path.nonmember/
2 lines
fs.op.funcs/
fs.op.remove_all/
4 lines
2 lines
input.output.general/
2 lines
iostream.format/
2 lines
output.streams/
ostream.formatted/
ostream.inserters.character/
2 lines
2 lines
2 lines
2 lines
quoted.manip/
2 lines
iostream.forward/
2 lines
iostream.objects/
2 lines
wide.stream.objects/
2 lines
2 lines
2 lines
2 lines
iostreams.base/
ios/
basic.ios.members/
2 lines
2 lines
iostreams.requirements/
2 lines
stream.buffers/
2 lines
string.streams/
2 lines
iterators/
stream.iterators/
2 lines
language.support/
support.limits/
support.limits.general/
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
localization/
2 lines
locale.categories/
category.ctype/
locale.codecvt.byname/
2 lines
locale.codecvt/
2 lines
locale.codecvt.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.ctype.byname/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.ctype/
2 lines
locale.ctype.members/
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
category.time/
locale.time.get.byname/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.time.get/
locale.time.get.members/
2 lines
2 lines
2 lines
2 lines
locale.stdcvt/
2 lines
2 lines
locales/
locale.convenience/
conversions/
conversions.buffer/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
conversions.string/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
namespace/
2 lines
numerics/
complex.number/
complex.ops/
2 lines
2 lines
rand/
rand.adapt/
rand.adapt.disc/
2 lines
2 lines
2 lines
rand.adapt.ibits/
2 lines
2 lines
2 lines
rand.adapt.shuf/
2 lines
2 lines
2 lines
rand.device/
2 lines
2 lines
2 lines
rand.dist/
rand.dist.bern/
rand.dist.bern.bernoulli/
2 lines
rand.dist.bern.bin/
2 lines
2 lines
rand.dist.bern.geo/
2 lines
rand.dist.bern.negbin/
2 lines
rand.dist.norm/
rand.dist.norm.cauchy/
2 lines
rand.dist.norm.chisq/
2 lines
rand.dist.norm.f/
2 lines
rand.dist.norm.lognormal/
2 lines
rand.dist.norm.normal/
2 lines
rand.dist.norm.t/
2 lines
rand.dist.pois/
rand.dist.pois.exp/
2 lines
rand.dist.pois.extreme/
2 lines
rand.dist.pois.gamma/
2 lines
rand.dist.pois.poisson/
2 lines
rand.dist.pois.weibull/
2 lines
rand.dist.samp/
rand.dist.samp.discrete/
2 lines
rand.dist.samp.pconst/
2 lines
rand.dist.samp.plinear/
2 lines
rand.dist.uni/
rand.dist.uni.int/
2 lines
rand.dist.uni.real/
2 lines
rand.eng/
rand.eng.lcong/
2 lines
2 lines
rand.eng.mers/
2 lines
2 lines
2 lines
rand.eng.sub/
2 lines
2 lines
2 lines
re/
2 lines
re.syn/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
strings/
basic.string/
string.capacity/
2 lines
string.nonmembers/
string.io/
2 lines
c.strings/
2 lines
2 lines
char.traits/
char.traits.specializations/
char.traits.specializations.wchar.t/
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.conversions/
2 lines
string.view/
string.view.io/
2 lines
string.view.nonmem/
2 lines
thread/
futures/
futures.async/
2 lines
2 lines
2 lines
2 lines
futures.errors/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
futures.future_error/
2 lines
2 lines
2 lines
futures.overview/
2 lines
2 lines
2 lines
2 lines
futures.promise/
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
futures.shared_future/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
futures.task/
futures.task.members/
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
futures.task.nonmembers/
2 lines
2 lines
futures.unique_future/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.barrier/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.condition/
2 lines
2 lines
thread.condition.condvar/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.condition.condvarany/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.latch/
2 lines
2 lines
2 lines
2 lines
thread.mutex/
thread.lock.algorithm/
2 lines
2 lines
thread.lock/
thread.lock.guard/
2 lines
2 lines
2 lines
2 lines
thread.lock.scoped/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.shared/
thread.lock.shared.cons/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.shared.locking/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.shared.mod/
2 lines
2 lines
2 lines
thread.lock.shared.obs/
2 lines
2 lines
2 lines
2 lines
thread.lock.unique/
thread.lock.unique.cons/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.unique.locking/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.unique.mod/
2 lines
2 lines
2 lines
thread.lock.unique.obs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.mutex.requirements/
thread.mutex.requirements.mutex/
thread.mutex.class/
2 lines
2 lines
2 lines
thread.mutex.recursive/
2 lines
2 lines
2 lines
thread.shared_mutex.requirements/
thread.shared_mutex.class/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.sharedtimedmutex.requirements/
thread.sharedtimedmutex.class/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.timedmutex.requirements/
thread.timedmutex.class/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.timedmutex.recursive/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.once/
thread.once.callonce/
2 lines
2 lines
thread.once.onceflag/
2 lines
2 lines
2 lines
thread.semaphore/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.threads/
thread.thread.class/
thread.thread.algorithm/
2 lines
thread.thread.assign/
2 lines
2 lines
thread.thread.constr/
2 lines
2 lines
2 lines
2 lines
thread.thread.destr/
2 lines
thread.thread.id/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
thread.thread.member/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.thread.static/
2 lines
thread.thread.this/
2 lines
2 lines
2 lines
time/
time.clock/
time.clock.file/
2 lines
2 lines
time.clock.steady/
2 lines
2 lines
utilities/
charconv/
charconv.msvc/
6 lines
format/
format.arguments/
format.arg.store/
2 lines
2 lines
format.formatter/
format.context/
format.context/
2 lines
2 lines
format.functions/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
memory/
unique.ptr/
unique.ptr.special/
2 lines
2 lines
util.smartptr/
util.smartptr.shared.atomic/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
util.smartptr.shared/
util.smartptr.shared.io/
2 lines
template.bitset/
bitset.operators/
2 lines
2 lines
support/
test.support/
2 lines
utils/
30 lines
28 lines
libcxx/
test/
15 lines
2 lines
libcxxabi/
test/
2 lines
2 lines
2 lines
libcxxabi/
test/
2 lines
2 lines
2 lines

Diff 432615

libcxx/test/libcxx/atomics/atomics.syn/incompatible_with_stdatomic.verify.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// REQUIRES: c++03 || c++11 || c++14 || c++17 || c++20 // REQUIRES: c++03 || c++11 || c++14 || c++17 || c++20
// This test ensures that we issue a reasonable diagnostic when including <atomic> after // This test ensures that we issue a reasonable diagnostic when including <atomic> after
// <stdatomic.h> has been included. Before C++23, this otherwise leads to obscure errors // <stdatomic.h> has been included. Before C++23, this otherwise leads to obscure errors
// because <atomic> may try to redefine things defined by <stdatomic.h>. // because <atomic> may try to redefine things defined by <stdatomic.h>.
// Ignore additional weird errors that happen when the two headers are mixed. // Ignore additional weird errors that happen when the two headers are mixed.
// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error -Xclang -verify-ignore-unexpected=warning // ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error -Xclang -verify-ignore-unexpected=warning
#include <stdatomic.h> #include <stdatomic.h>
#include <atomic> #include <atomic>
// expected-error@*:* {{<atomic> is incompatible with <stdatomic.h> before C++23.}} // expected-error@*:* {{<atomic> is incompatible with <stdatomic.h> before C++23.}}

libcxx/test/libcxx/atomics/stdatomic.h.syn/dont_hijack_header.compile.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// This test ensures that we don't hijack the <stdatomic.h> header even when compiling // This test ensures that we don't hijack the <stdatomic.h> header even when compiling
// before C++23, since Clang used to provide that header before libc++ provided one. // before C++23, since Clang used to provide that header before libc++ provided one.
// On GCC, the compiler-provided <stdatomic.h> is not C++ friendly, so including <stdatomic.h> // On GCC, the compiler-provided <stdatomic.h> is not C++ friendly, so including <stdatomic.h>
// doesn't work at all if we don't use the <stdatomic.h> provided by libc++ in C++23 and above. // doesn't work at all if we don't use the <stdatomic.h> provided by libc++ in C++23 and above.
// XFAIL: (c++11 || c++14 || c++17 || c++20) && gcc // XFAIL: (c++11 || c++14 || c++17 || c++20) && gcc
#include <stdatomic.h> #include <stdatomic.h>
void f() { void f() {
atomic_int i; // just make sure the header isn't empty atomic_int i; // just make sure the header isn't empty
(void)i; (void)i;
} }

libcxx/test/libcxx/debug/containers.multithread.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++11, c++14 // UNSUPPORTED: c++11, c++14
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: libcxx-no-debug-mode, c++03 // UNSUPPORTED: libcxx-no-debug-mode, c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
// test multithreaded container debugging // test multithreaded container debugging
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/test/libcxx/debug/extern-templates.sh.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// This test checks that we retain extern template instantiation declarations // This test checks that we retain extern template instantiation declarations
// for members of <locale> even when the debug mode is enabled, which is // for members of <locale> even when the debug mode is enabled, which is
// necessary for correctness. See https://llvm.org/D94718 for details. // necessary for correctness. See https://llvm.org/D94718 for details.
// UNSUPPORTED: libcxx-no-debug-mode // UNSUPPORTED: libcxx-no-debug-mode
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: cant-build-shared-library // UNSUPPORTED: cant-build-shared-library
// This test relies on linking a shared library and then passing that shared // This test relies on linking a shared library and then passing that shared
// library as input when linking an executable; this is generally not supported // library as input when linking an executable; this is generally not supported
// on Windows (GNU ld supports it, but MS link.exe and LLD don't) - one has to // on Windows (GNU ld supports it, but MS link.exe and LLD don't) - one has to
// use an import library instead. (Additionally, the test uses the -fPIC // use an import library instead. (Additionally, the test uses the -fPIC
// option which clang doesn't accept on Windows.) // option which clang doesn't accept on Windows.)
// UNSUPPORTED: windows // UNSUPPORTED: windows
Show All 32 Lines

libcxx/test/libcxx/depr/depr.c.headers/locale_h.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <locale.h> // <locale.h>
#include <locale.h> #include <locale.h>
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/depr/depr.str.strstreams/version.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <strstream> // <strstream>
#include <strstream> #include <strstream>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.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
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <experimental/regex> // <experimental/regex>
#include <experimental/regex> #include <experimental/regex>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error header must provide _LIBCPP_VERSION #error header must provide _LIBCPP_VERSION
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/fuzzing/regex.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, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: no-exceptions // UNSUPPORTED: no-exceptions
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <regex> #include <regex>
#include <string> #include <string>
#include "fuzz.h" #include "fuzz.h"
Show All 27 Lines

libcxx/test/libcxx/gdb/gdb_pretty_printer_test.sh.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: host-has-gdb-with-python // REQUIRES: host-has-gdb-with-python
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// TODO: Investigate this failure, which happens only with the Bootstrapping build. // TODO: Investigate this failure, which happens only with the Bootstrapping build.
// UNSUPPORTED: clang-14, clang-15 // UNSUPPORTED: clang-14, clang-15
// RUN: %{cxx} %{flags} %s -o %t.exe %{compile_flags} -g %{link_flags} // RUN: %{cxx} %{flags} %s -o %t.exe %{compile_flags} -g %{link_flags}
// Ensure locale-independence for unicode tests. // Ensure locale-independence for unicode tests.
// RUN: env LANG=en_US.UTF-8 %{gdb} -nx -batch -iex "set autoload off" -ex "source %S/../../../utils/gdb/libcxx/printers.py" -ex "python register_libcxx_printer_loader()" -ex "source %S/gdb_pretty_printer_test.py" %t.exe // RUN: env LANG=en_US.UTF-8 %{gdb} -nx -batch -iex "set autoload off" -ex "source %S/../../../utils/gdb/libcxx/printers.py" -ex "python register_libcxx_printer_loader()" -ex "source %S/gdb_pretty_printer_test.py" %t.exe
▲ Show 20 Lines • Show All 670 Lines • Show Last 20 Lines

libcxx/test/libcxx/inclusions/filesystem.inclusions.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_header_inclusion_tests.py // WARNING: This test was generated by generate_header_inclusion_tests.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// <filesystem> // <filesystem>
// Test that <filesystem> includes all the other headers it's supposed to. // Test that <filesystem> includes all the other headers it's supposed to.
#include <filesystem> #include <filesystem>
#include "test_macros.h" #include "test_macros.h"
#if !defined(_LIBCPP_FILESYSTEM) #if !defined(_LIBCPP_FILESYSTEM)
# error "<filesystem> was expected to define _LIBCPP_FILESYSTEM" # error "<filesystem> was expected to define _LIBCPP_FILESYSTEM"
#endif #endif
#if TEST_STD_VER > 17 && !defined(_LIBCPP_COMPARE) #if TEST_STD_VER > 17 && !defined(_LIBCPP_COMPARE)
# error "<filesystem> should include <compare> in C++20 and later" # error "<filesystem> should include <compare> in C++20 and later"
#endif #endif

libcxx/test/libcxx/inclusions/ios.inclusions.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_header_inclusion_tests.py // WARNING: This test was generated by generate_header_inclusion_tests.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <ios> // <ios>
// Test that <ios> includes all the other headers it's supposed to. // Test that <ios> includes all the other headers it's supposed to.
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#if !defined(_LIBCPP_IOS) #if !defined(_LIBCPP_IOS)
# error "<ios> was expected to define _LIBCPP_IOS" # error "<ios> was expected to define _LIBCPP_IOS"
#endif #endif
#if !defined(_LIBCPP_IOSFWD) #if !defined(_LIBCPP_IOSFWD)
# error "<ios> should include <iosfwd> in C++03 and later" # error "<ios> should include <iosfwd> in C++03 and later"
#endif #endif

libcxx/test/libcxx/inclusions/iostream.inclusions.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_header_inclusion_tests.py // WARNING: This test was generated by generate_header_inclusion_tests.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <iostream> // <iostream>
// Test that <iostream> includes all the other headers it's supposed to. // Test that <iostream> includes all the other headers it's supposed to.
#include <iostream> #include <iostream>
#include "test_macros.h" #include "test_macros.h"
Show All 15 Lines

libcxx/test/libcxx/inclusions/regex.inclusions.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_header_inclusion_tests.py // WARNING: This test was generated by generate_header_inclusion_tests.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <regex> // <regex>
// Test that <regex> includes all the other headers it's supposed to. // Test that <regex> includes all the other headers it's supposed to.
#include <regex> #include <regex>
#include "test_macros.h" #include "test_macros.h"
Show All 9 Lines

libcxx/test/libcxx/inclusions/thread.inclusions.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_header_inclusion_tests.py // WARNING: This test was generated by generate_header_inclusion_tests.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// Test that <thread> includes all the other headers it's supposed to. // Test that <thread> includes all the other headers it's supposed to.
#include <thread> #include <thread>
#include "test_macros.h" #include "test_macros.h"
#if !defined(_LIBCPP_THREAD) #if !defined(_LIBCPP_THREAD)
# error "<thread> was expected to define _LIBCPP_THREAD" # error "<thread> was expected to define _LIBCPP_THREAD"
#endif #endif
#if TEST_STD_VER > 17 && !defined(_LIBCPP_COMPARE) #if TEST_STD_VER > 17 && !defined(_LIBCPP_COMPARE)
# error "<thread> should include <compare> in C++20 and later" # error "<thread> should include <compare> in C++20 and later"
#endif #endif

libcxx/test/libcxx/input.output/filesystems/class.path/path.member/path.native.obs/string_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
// These tests require locale for non-char paths // These tests require locale for non-char paths
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// template <class ECharT, class Traits = char_traits<ECharT>, // template <class ECharT, class Traits = char_traits<ECharT>,
// class Allocator = allocator<ECharT>> // class Allocator = allocator<ECharT>>
// basic_string<ECharT, Traits, Allocator> // basic_string<ECharT, Traits, Allocator>
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// The char type of the stream and the char_type of the traits have to match // The char type of the stream and the char_type of the traits have to match
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <istream> #include <istream>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
struct test_istream struct test_istream
: public std::basic_istream<char, std::char_traits<wchar_t> > {}; : public std::basic_istream<char, std::char_traits<wchar_t> > {};
int main(int, char**) int main(int, char**)
{ {
// expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}} // expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
return 0; return 0;
} }

libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ostream> // <ostream>
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_ostream; // class basic_ostream;
// The char type of the stream and the char_type of the traits have to match // The char type of the stream and the char_type of the traits have to match
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <ostream> #include <ostream>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
struct test_ostream struct test_ostream
: public std::basic_ostream<char, std::char_traits<wchar_t> > {}; : public std::basic_ostream<char, std::char_traits<wchar_t> > {};
int main(int, char**) int main(int, char**)
{ {
// expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}} // expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
return 0; return 0;
} }

libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <sstream> // <sstream>
// template<class charT, class traits = char_traits<charT>, // template<class charT, class traits = char_traits<charT>,
// class Allocator = allocator<charT>> // class Allocator = allocator<charT>>
// class basic_stringbuf; // class basic_stringbuf;
// //
// The char type of the stream and the char_type of the traits have to match // The char type of the stream and the char_type of the traits have to match
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <sstream> #include <sstream>
int main(int, char**) int main(int, char**)
{ {
std::basic_stringbuf<char, std::char_traits<wchar_t> > sb; std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
// expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}} // expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
// expected-error-re@string:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}} // expected-error-re@string:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
return 0; return 0;
} }

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/locale_dependent.compile.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <iterator> #include <iterator>
#include <istream> #include <istream>
#include <ostream> #include <ostream>
static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::istream_iterator<int, std::istream> >); static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::istream_iterator<int, std::istream> >);
static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::istreambuf_iterator<int, std::istream> >); static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::istreambuf_iterator<int, std::istream> >);
Show All 32 Lines

libcxx/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <locale> // <locale>
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(wstring_convert&& other); // EXTENSION // wstring_convert(wstring_convert&& other); // EXTENSION
Show All 23 Lines

libcxx/test/libcxx/modules_include.sh.cpp

Show All 15 Lines
// GCC doesn't support -fcxx-modules // GCC doesn't support -fcxx-modules
// UNSUPPORTED: gcc // UNSUPPORTED: gcc
// The Windows headers don't appear to be compatible with modules // The Windows headers don't appear to be compatible with modules
// UNSUPPORTED: windows // UNSUPPORTED: windows
// TODO: Some headers produce errors when we include them and the library has been // TODO: Some headers produce errors when we include them and the library has been
// configured without support for them, which breaks the modules build. // configured without support for them, which breaks the modules build.
// UNSUPPORTED: libcpp-has-no-localization, libcpp-has-no-filesystem-library, libcpp-has-no-threads, libcpp-has-no-wide-characters // UNSUPPORTED: no-localization, no-filesystem, no-threads, no-wide-characters
// Prevent <ext/hash_map> from generating deprecated warnings for this test. // Prevent <ext/hash_map> from generating deprecated warnings for this test.
#if defined(__DEPRECATED) #if defined(__DEPRECATED)
# undef __DEPRECATED # undef __DEPRECATED
#endif #endif
#include <__config> #include <__config>
▲ Show 20 Lines • Show All 578 Lines • Show Last 20 Lines

libcxx/test/libcxx/numerics/rand/rand.device/has-no-random-device.verify.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Make sure that std::random_device is not available in namespace std:: when // Make sure that std::random_device is not available in namespace std:: when
// libc++ is built without support for random device. // libc++ is built without support for random device.
// REQUIRES: libcpp-has-no-random-device // REQUIRES: no-random-device
#include <random> #include <random>
int main(int, char**) { int main(int, char**) {
std::random_device d; // expected-error {{no type named 'random_device' in namespace 'std'}} std::random_device d; // expected-error {{no type named 'random_device' in namespace 'std'}}
return 0; return 0;
} }

libcxx/test/libcxx/ranges/has-no-incomplete-ranges.compile.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// REQUIRES: libcpp-has-no-incomplete-ranges // REQUIRES: libcpp-has-no-incomplete-ranges
// Test that _LIBCPP_HAS_NO_INCOMPLETE_RANGES disables the std::ranges namespace. // Test that _LIBCPP_HAS_NO_INCOMPLETE_RANGES disables the std::ranges namespace.
#include <algorithm> #include <algorithm>
#include <concepts> #include <concepts>
#include <filesystem> #include <filesystem>
#include <iterator> #include <iterator>
Show All 22 Lines

libcxx/test/libcxx/strings/c.strings/version_cwchar.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <cwchar> // <cwchar>
#include <cwchar> #include <cwchar>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/strings/c.strings/version_cwctype.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <cwctype> // <cwctype>
#include <cwctype> #include <cwctype>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/thread/futures/futures.promise/assert.set_exception.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unix-headers // REQUIRES: has-unix-headers
// UNSUPPORTED: c++03, libcpp-has-no-threads // UNSUPPORTED: c++03, no-threads
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.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|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <future> // <future>
// class promise<R> // class promise<R>
// void set_exception(exception_ptr p); // void set_exception(exception_ptr p);
Show All 22 Lines

libcxx/test/libcxx/thread/futures/futures.promise/assert.set_exception_at_thread_exit.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: has-unix-headers // REQUIRES: has-unix-headers
// UNSUPPORTED: c++03, libcpp-has-no-threads // UNSUPPORTED: c++03, no-threads
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.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|12.0}}
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
// <future> // <future>
// class promise<R> // class promise<R>
// void set_exception_on_thread_exit(exception_ptr p); // void set_exception_on_thread_exit(exception_ptr p);
Show All 22 Lines

libcxx/test/libcxx/thread/futures/futures.task/types.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// template<class R, class... ArgTypes> // template<class R, class... ArgTypes>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// { // {
// public: // public:
Show All 17 Lines

libcxx/test/libcxx/thread/futures/version.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
#include <future> #include <future>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/thread/thread.barrier/version.compile.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <barrier> // <barrier>
#include <barrier> #include <barrier>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// REQUIRES: libcpp-has-thread-api-pthread // REQUIRES: libcpp-has-thread-api-pthread
// notify_all_at_thread_exit(...) requires move semantics to transfer the // notify_all_at_thread_exit(...) requires move semantics to transfer the
// unique_lock. // unique_lock.
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// PR30202 was fixed starting in macosx10.13. // PR30202 was fixed starting in macosx10.13.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.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: libcpp-has-no-threads, libcpp-has-thread-api-external // UNSUPPORTED: no-threads, libcpp-has-thread-api-external
// XFAIL: windows // XFAIL: windows
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// typedef pthread_cond_t* native_handle_type; // typedef pthread_cond_t* native_handle_type;
Show All 17 Lines

libcxx/test/libcxx/thread/thread.condition/version.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
#include <condition_variable> #include <condition_variable>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/thread/thread.latch/version.compile.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <latch> // <latch>
#include <latch> #include <latch>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/thread/thread.lock/thread.lock.guard/nodiscard.verify.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// [[nodiscard]] isn't supported in C++03 (not even as an extension) // [[nodiscard]] isn't supported in C++03 (not even as an extension)
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <mutex> // <mutex>
// template <class Mutex> class lock_guard; // template <class Mutex> class lock_guard;
Show All 16 Lines

libcxx/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.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: libcpp-has-no-threads, libcpp-has-thread-api-external // UNSUPPORTED: no-threads, libcpp-has-thread-api-external
// XFAIL: windows // XFAIL: windows
// <mutex> // <mutex>
// class mutex; // class mutex;
// typedef pthread_mutex_t* native_handle_type; // typedef pthread_mutex_t* native_handle_type;
Show All 15 Lines

libcxx/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.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: libcpp-has-no-threads, libcpp-has-thread-api-external // UNSUPPORTED: no-threads, libcpp-has-thread-api-external
// XFAIL: windows // XFAIL: windows
// <mutex> // <mutex>
// class recursive_mutex; // class recursive_mutex;
// typedef pthread_mutex_t* native_handle_type; // typedef pthread_mutex_t* native_handle_type;
Show All 15 Lines

libcxx/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// This test does not define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS so it // This test does not define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS so it
// should compile without any warnings or errors even though this pattern is not // should compile without any warnings or errors even though this pattern is not
// understood by the thread safety annotations. // understood by the thread safety annotations.
#include <mutex> #include <mutex>
Show All 12 Lines

libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// On Windows Clang bugs out when both __declspec and __attribute__ are present, // On Windows Clang bugs out when both __declspec and __attribute__ are present,
// the processing goes awry preventing the definition of the types. // the processing goes awry preventing the definition of the types.
// XFAIL: msvc // XFAIL: msvc
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// REQUIRES: thread-safety // REQUIRES: thread-safety
// <mutex> // <mutex>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
#include <mutex> #include <mutex>
Show All 19 Lines

libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// On Windows Clang bugs out when both __declspec and __attribute__ are present, // On Windows Clang bugs out when both __declspec and __attribute__ are present,
// the processing goes awry preventing the definition of the types. // the processing goes awry preventing the definition of the types.
// XFAIL: msvc // XFAIL: msvc
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// REQUIRES: thread-safety // REQUIRES: thread-safety
// <mutex> // <mutex>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
#include <mutex> #include <mutex>
Show All 12 Lines

libcxx/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// On Windows Clang bugs out when both __declspec and __attribute__ are present, // On Windows Clang bugs out when both __declspec and __attribute__ are present,
// the processing goes awry preventing the definition of the types. // the processing goes awry preventing the definition of the types.
// XFAIL: msvc // XFAIL: msvc
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// REQUIRES: thread-safety // REQUIRES: thread-safety
// <mutex> // <mutex>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
#include <mutex> #include <mutex>
std::mutex m; std::mutex m;
int main(int, char**) { int main(int, char**) {
m.lock(); m.lock();
return 0; return 0;
} // expected-error {{mutex 'm' is still held at the end of function}} } // expected-error {{mutex 'm' is still held at the end of function}}

libcxx/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// On Windows Clang bugs out when both __declspec and __attribute__ are present, // On Windows Clang bugs out when both __declspec and __attribute__ are present,
// the processing goes awry preventing the definition of the types. // the processing goes awry preventing the definition of the types.
// XFAIL: msvc // XFAIL: msvc
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// REQUIRES: thread-safety // REQUIRES: thread-safety
// <mutex> // <mutex>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
#include <mutex> #include <mutex>
Show All 16 Lines

libcxx/test/libcxx/thread/thread.mutex/version.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
#include <mutex> #include <mutex>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/thread/thread.semaphore/version.compile.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <semaphore> // <semaphore>
#include <semaphore> #include <semaphore>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/thread/thread.threads/create_late.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
#include "make_test_thread.h" #include "make_test_thread.h"
void func() {} void func() {}
struct T { struct T {
~T() { ~T() {
Show All 12 Lines

libcxx/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.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: libcpp-has-no-threads, libcpp-has-thread-api-external // UNSUPPORTED: no-threads, libcpp-has-thread-api-external
// XFAIL: windows // XFAIL: windows
// <thread> // <thread>
// class thread // class thread
// native_handle_type native_handle(); // native_handle_type native_handle();
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/libcxx/thread/thread.threads/thread.thread.class/types.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: libcpp-has-no-threads, libcpp-has-thread-api-external // UNSUPPORTED: no-threads, libcpp-has-thread-api-external
// REQUIRES: libcpp-has-thread-api-pthread // REQUIRES: libcpp-has-thread-api-pthread
// <thread> // <thread>
// class thread // class thread
// { // {
// public: // public:
// typedef pthread_t native_handle_type; // typedef pthread_t native_handle_type;
Show All 14 Lines

libcxx/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// Until 58a0a70fb2f1, this_thread::sleep_for could sometimes get interrupted // Until 58a0a70fb2f1, this_thread::sleep_for could sometimes get interrupted
// by signals and this test would fail spuriously. Disable the test on the // by signals and this test would fail spuriously. Disable the test on the
// corresponding system libraries. // corresponding system libraries.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// ALLOW_RETRIES: 3 // ALLOW_RETRIES: 3
Show All 23 Lines

libcxx/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.signals.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// This test uses the POSIX header <sys/time.h> which Windows doesn't provide // This test uses the POSIX header <sys/time.h> which Windows doesn't provide
// UNSUPPORTED: windows // UNSUPPORTED: windows
// Until 58a0a70fb2f1, this_thread::sleep_for misbehaves when interrupted by // Until 58a0a70fb2f1, this_thread::sleep_for misbehaves when interrupted by
// a signal, as tested here. Disable the test on the corresponding system // a signal, as tested here. Disable the test on the corresponding system
// libraries. // libraries.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/libcxx/thread/thread.threads/version.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
#include <thread> #include <thread>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/utilities/memory/util.smartptr/race_condition.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// //
// <memory> // <memory>
// //
// class shared_ptr // class shared_ptr
// //
// This test attempts to create a race condition surrounding use_count() // This test attempts to create a race condition surrounding use_count()
// with the hope that TSAN will diagnose it. // with the hope that TSAN will diagnose it.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_notify_all.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// XFAIL: c++03 // XFAIL: c++03
// XFAIL: !non-lockfree-atomics // XFAIL: !non-lockfree-atomics
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <atomic> // <atomic>
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_notify_one.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// XFAIL: c++03 // XFAIL: c++03
// XFAIL: !non-lockfree-atomics // XFAIL: !non-lockfree-atomics
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <atomic> // <atomic>
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_wait.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// XFAIL: c++03 // XFAIL: c++03
// XFAIL: !non-lockfree-atomics // XFAIL: !non-lockfree-atomics
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <atomic> // <atomic>
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_wait_explicit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// XFAIL: c++03 // XFAIL: c++03
// XFAIL: !non-lockfree-atomics // XFAIL: !non-lockfree-atomics
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <atomic> // <atomic>
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/atomics/stdatomic.h.syn/types.compile.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, c++11, c++14, c++17, c++20 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <stdatomic.h> // <stdatomic.h>
// template<class T> // template<class T>
// using std-atomic = std::atomic<T>; // exposition only // using std-atomic = std::atomic<T>; // exposition only
// //
// #define _Atomic(T) std-atomic<T> // #define _Atomic(T) std-atomic<T>
// //
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

libcxx/test/std/containers/iterator.rel_ops.compile.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: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// std::filesystem is unavailable prior to macOS 10.15 // std::filesystem is unavailable prior to macOS 10.15
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// Make sure the various containers' iterators are not broken by the use of `std::rel_ops`. // Make sure the various containers' iterators are not broken by the use of `std::rel_ops`.
#include <utility> // for std::rel_ops #include <utility> // for std::rel_ops
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

libcxx/test/std/depr/depr.c.headers/locale_h.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <locale.h> // <locale.h>
#include <locale.h> #include <locale.h>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
Show All 36 Lines

libcxx/test/std/depr/depr.c.headers/wchar_h.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <wchar.h> // <wchar.h>
#include <wchar.h> #include <wchar.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <type_traits> #include <type_traits>
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libcxx/test/std/depr/depr.c.headers/wctype_h.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <wctype.h> // <wctype.h>
#include <wctype.h> #include <wctype.h>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

libcxx/test/std/depr/depr.ios.members/lit.local.cfg

if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/depr/depr.str.strstreams/lit.local.cfg

if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <system_error> // <system_error>
// class error_code // class error_code
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT,traits>& // basic_ostream<charT,traits>&
// operator<<(basic_ostream<charT,traits>& os, const error_code& ec); // operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
Show All 15 Lines

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.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, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <experimental/iterator> // <experimental/iterator>
// //
// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
// class ostream_joiner; // class ostream_joiner;
// //
// ostream_joiner(ostream_type& __os, _Delim&& __d); // ostream_joiner(ostream_type& __os, _Delim&& __d);
// ostream_joiner(ostream_type& __os, const _Delim& __d); // ostream_joiner(ostream_type& __os, const _Delim& __d);
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.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, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <experimental/iterator> // <experimental/iterator>
// //
// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
// class ostream_joiner; // class ostream_joiner;
// //
// template <class _CharT, class _Traits, class _Delim> // template <class _CharT, class _Traits, class _Delim>
// ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits> // ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>
Show All 37 Lines

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.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, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <experimental/iterator> // <experimental/iterator>
// //
// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
// class ostream_joiner; // class ostream_joiner;
// //
// template<typename T> // template<typename T>
// ostream_joiner & operator=(const T&) // ostream_joiner & operator=(const T&)
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.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, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <experimental/iterator> // <experimental/iterator>
// //
// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
// class ostream_joiner; // class ostream_joiner;
// //
// ostream_joiner & operator++(int) noexcept // ostream_joiner & operator++(int) noexcept
// returns *this; // returns *this;
Show All 34 Lines

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.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, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <experimental/iterator> // <experimental/iterator>
// //
// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
// class ostream_joiner; // class ostream_joiner;
// //
// ostream_joiner & operator++() noexcept // ostream_joiner & operator++() noexcept
// returns *this; // returns *this;
Show All 34 Lines

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.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, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <experimental/iterator> // <experimental/iterator>
// //
// template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
// class ostream_joiner; // class ostream_joiner;
// //
// ostream_joiner & operator*() noexcept // ostream_joiner & operator*() noexcept
// returns *this; // returns *this;
Show All 34 Lines

libcxx/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.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
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <experimental/regex> // <experimental/regex>
// namespace std { namespace experimental { namespace pmr { // namespace std { namespace experimental { namespace pmr {
// //
// template <class BidirectionalIterator> // template <class BidirectionalIterator>
// using match_results = // using match_results =
// std::match_results<BidirectionalIterator, // std::match_results<BidirectionalIterator,
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.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, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// <fstream> // <fstream>
// basic_filebuf<charT,traits>* open(const filesystem::path& p, ios_base::openmode mode); // basic_filebuf<charT,traits>* open(const filesystem::path& p, ios_base::openmode mode);
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/path.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, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// <fstream> // <fstream>
// plate <class charT, class traits = char_traits<charT> > // plate <class charT, class traits = char_traits<charT> >
// class basic_fstream // class basic_fstream
Show All 40 Lines

libcxx/test/std/input.output/file.streams/fstreams/fstream.members/open_path.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, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// <fstream> // <fstream>
// plate <class charT, class traits = char_traits<charT> > // plate <class charT, class traits = char_traits<charT> >
// class basic_fstream // class basic_fstream
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/path.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, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// FILE_DEPENDENCIES: test.dat // FILE_DEPENDENCIES: test.dat
// <fstream> // <fstream>
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.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, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// FILE_DEPENDENCIES: test.dat // FILE_DEPENDENCIES: test.dat
// <fstream> // <fstream>
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/path.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, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// <fstream> // <fstream>
// plate <class charT, class traits = char_traits<charT> > // plate <class charT, class traits = char_traits<charT> >
// class basic_ofstream // class basic_ofstream
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.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, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// <fstream> // <fstream>
// plate <class charT, class traits = char_traits<charT> > // plate <class charT, class traits = char_traits<charT> >
// class basic_ofstream // class basic_ofstream
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/input.output/file.streams/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.io/directory_entry.io.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
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// //
// class directory_entry // class directory_entry
// //
// template<class charT, class traits> // template<class charT, class traits>
// friend basic_ostream<charT, traits>& // friend basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const directory_entry& d); // operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
Show All 36 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.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
// These tests require locale for non-char paths // These tests require locale for non-char paths
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// path& operator/=(path const&) // path& operator/=(path const&)
// template <class Source> // template <class Source>
// path& operator/=(Source const&); // path& operator/=(Source const&);
▲ Show 20 Lines • Show All 385 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.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
// These tests require locale for non-char paths // These tests require locale for non-char paths
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// template <class Source> // template <class Source>
// path& operator=(Source const&); // path& operator=(Source const&);
// path& operator=(string_type&&); // path& operator=(string_type&&);
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.charconv.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// <filesystem> // <filesystem>
// class path // class path
// Test constructors, accessors and modifiers that convert from/to various // Test constructors, accessors and modifiers that convert from/to various
▲ Show 20 Lines • Show All 394 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.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
// These tests require locale for non-char paths // These tests require locale for non-char paths
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// path& operator+=(const path& x); // path& operator+=(const path& x);
// path& operator+=(const string_type& x); // path& operator+=(const string_type& x);
// path& operator+=(string_view x); // path& operator+=(string_view x);
▲ Show 20 Lines • Show All 392 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.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
// These tests require locale for non-char paths // These tests require locale for non-char paths
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// template <class Source> // template <class Source>
// path(const Source& source); // path(const Source& source);
// template <class InputIterator> // template <class InputIterator>
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_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
// These tests require locale for non-char paths // These tests require locale for non-char paths
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// template <class ECharT, class Traits = char_traits<ECharT>, // template <class ECharT, class Traits = char_traits<ECharT>,
// class Allocator = allocator<ECharT>> // class Allocator = allocator<ECharT>>
// basic_string<ECharT, Traits, Allocator> // basic_string<ECharT, Traits, Allocator>
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.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
// These tests require locale for non-char paths // These tests require locale for non-char paths
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// std::string generic_string() const; // std::string generic_string() const;
// std::wstring generic_wstring() const; // std::wstring generic_wstring() const;
// std::u8string generic_u8string() const; // std::u8string generic_u8string() const;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.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
// These tests require locale for non-char paths // These tests require locale for non-char paths
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// std::string string() const; // std::string string() const;
// std::wstring wstring() const; // std::wstring wstring() const;
// std::u8string u8string() const; // std::u8string u8string() const;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.io.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
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <filesystem> // <filesystem>
// class path // class path
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const path& p); // operator<<(basic_ostream<charT, traits>& os, const path& p);
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/toctou.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
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <filesystem> // <filesystem>
// Test for a time-of-check to time-of-use issue with std::filesystem::remove_all. // Test for a time-of-check to time-of-use issue with std::filesystem::remove_all.
// //
// Scenario: // Scenario:
// The attacker wants to get directory contents deleted, to which he does not have access. // The attacker wants to get directory contents deleted, to which he does not have access.
// He has a way to get a privileged binary call `std::filesystem::remove_all()` on a // He has a way to get a privileged binary call `std::filesystem::remove_all()` on a
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/lit.local.cfg

# Filesystem is supported on Apple platforms starting with macosx10.15. # Filesystem is supported on Apple platforms starting with macosx10.15.
# Automatically disable the <filesystem> tests when we're running the test # Automatically disable the <filesystem> tests when we're running the test
# suite against an older macOS. # suite against an older macOS.
too_old = {'10.9', '10.10', '10.11', '10.12', '10.13', '10.14'} too_old = {'10.9', '10.10', '10.11', '10.12', '10.13', '10.14'}
if 'use_system_cxx_lib' in config.available_features: if 'use_system_cxx_lib' in config.available_features:
if any('target=x86_64-apple-macosx{}'.format(v) in config.available_features for v in too_old): if any('target=x86_64-apple-macosx{}'.format(v) in config.available_features for v in too_old):
config.unsupported = True config.unsupported = True
if 'libcpp-has-no-filesystem-library' in config.available_features: if 'no-filesystem' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/input.output.general/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/iostream.format/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ostream> // <ostream>
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_ostream; // class basic_ostream;
// template<class charT, class traits> // template<class charT, class traits>
// basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, charT c); // basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, charT c);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <ostream> #include <ostream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class CharT> template <class CharT>
class testbuf class testbuf
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ostream> // <ostream>
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_ostream; // class basic_ostream;
// template<class charT, class traits> // template<class charT, class traits>
// basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, const charT* s); // basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, const charT* s);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <ostream> #include <ostream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class CharT> template <class CharT>
class testbuf class testbuf
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ostream> // <ostream>
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_ostream; // class basic_ostream;
// template<class charT, class traits> // template<class charT, class traits>
// basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, char c); // basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, char c);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <ostream> #include <ostream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class CharT> template <class CharT>
class testbuf class testbuf
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ostream> // <ostream>
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_ostream; // class basic_ostream;
// template<class charT, class traits> // template<class charT, class traits>
// basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, const char* s); // basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, const char* s);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <ostream> #include <ostream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class CharT> template <class CharT>
class testbuf class testbuf
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_char.verify.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iomanip> // <iomanip>
// quoted // quoted
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <iomanip> #include <iomanip>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 12 Lines

libcxx/test/std/input.output/iostream.forward/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/iostream.objects/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.sh.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iostream> // <iostream>
// istream wcerr; // istream wcerr;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// UNSUPPORTED: executor-has-no-bash // UNSUPPORTED: executor-has-no-bash
// FILE_DEPENDENCIES: ../check-stderr.sh // FILE_DEPENDENCIES: ../check-stderr.sh
// RUN: %{build} // RUN: %{build}
// RUN: %{exec} bash check-stderr.sh "%t.exe" "1234" // RUN: %{exec} bash check-stderr.sh "%t.exe" "1234"
#include <iostream> #include <iostream>
#include <cassert> #include <cassert>
Show All 9 Lines

libcxx/test/std/input.output/iostream.objects/wide.stream.objects/wcin.sh.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iostream> // <iostream>
// istream wcin; // istream wcin;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// UNSUPPORTED: executor-has-no-bash // UNSUPPORTED: executor-has-no-bash
// FILE_DEPENDENCIES: ../send-stdin.sh // FILE_DEPENDENCIES: ../send-stdin.sh
// RUN: %{build} // RUN: %{build}
// RUN: %{exec} bash send-stdin.sh "%t.exe" "1234" // RUN: %{exec} bash send-stdin.sh "%t.exe" "1234"
#include <iostream> #include <iostream>
#include <cassert> #include <cassert>
int main(int, char**) { int main(int, char**) {
int i; int i;
std::wcin >> i; std::wcin >> i;
assert(i == 1234); assert(i == 1234);
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.objects/wide.stream.objects/wclog.sh.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iostream> // <iostream>
// istream wclog; // istream wclog;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// UNSUPPORTED: executor-has-no-bash // UNSUPPORTED: executor-has-no-bash
// FILE_DEPENDENCIES: ../check-stderr.sh // FILE_DEPENDENCIES: ../check-stderr.sh
// RUN: %{build} // RUN: %{build}
// RUN: %{exec} bash check-stderr.sh "%t.exe" "1234" // RUN: %{exec} bash check-stderr.sh "%t.exe" "1234"
#include <iostream> #include <iostream>
int main(int, char**) { int main(int, char**) {
std::wclog << L"1234"; std::wclog << L"1234";
return 0; return 0;
} }

libcxx/test/std/input.output/iostream.objects/wide.stream.objects/wcout.sh.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iostream> // <iostream>
// istream wcout; // istream wcout;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// UNSUPPORTED: executor-has-no-bash // UNSUPPORTED: executor-has-no-bash
// FILE_DEPENDENCIES: ../check-stdout.sh // FILE_DEPENDENCIES: ../check-stdout.sh
// RUN: %{build} // RUN: %{build}
// RUN: %{exec} bash check-stdout.sh "%t.exe" "1234" // RUN: %{exec} bash check-stdout.sh "%t.exe" "1234"
#include <iostream> #include <iostream>
int main(int, char**) { int main(int, char**) {
std::wcout << L"1234"; std::wcout << L"1234";
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ios> // <ios>
// template <class charT, class traits> class basic_ios // template <class charT, class traits> class basic_ios
// char narrow(char_type c, char dfault) const; // char narrow(char_type c, char dfault) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <ios> #include <ios>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
const std::wios ios(0); const std::wios ios(0);
assert(ios.narrow(L'c', '*') == 'c'); assert(ios.narrow(L'c', '*') == 'c');
assert(ios.narrow(L'\u203C', '*') == '*'); assert(ios.narrow(L'\u203C', '*') == '*');
return 0; return 0;
} }

libcxx/test/std/input.output/iostreams.base/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/iostreams.requirements/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/stream.buffers/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/input.output/string.streams/lit.local.cfg

# All non-trivial uses of iostreams require localization support # All non-trivial uses of iostreams require localization support
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/iterators/stream.iterators/lit.local.cfg

# stream iterators rely on the streams library, which requires localization # stream iterators rely on the streams library, which requires localization
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/language.support/support.limits/support.limits.general/barrier.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <barrier> // <barrier>
// Test the feature test macros defined by <barrier> // Test the feature test macros defined by <barrier>
/* Constant Value /* Constant Value
__cpp_lib_barrier 201907L [C++20] __cpp_lib_barrier 201907L [C++20]
*/ */
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/filesystem.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// <filesystem> // <filesystem>
// Test the feature test macros defined by <filesystem> // Test the feature test macros defined by <filesystem>
/* Constant Value /* Constant Value
__cpp_lib_char8_t 201811L [C++20] __cpp_lib_char8_t 201811L [C++20]
__cpp_lib_filesystem 201703L [C++17] __cpp_lib_filesystem 201703L [C++17]
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/iomanip.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <iomanip> // <iomanip>
// Test the feature test macros defined by <iomanip> // Test the feature test macros defined by <iomanip>
/* Constant Value /* Constant Value
__cpp_lib_quoted_string_io 201304L [C++14] __cpp_lib_quoted_string_io 201304L [C++14]
*/ */
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/istream.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <istream> // <istream>
// Test the feature test macros defined by <istream> // Test the feature test macros defined by <istream>
/* Constant Value /* Constant Value
__cpp_lib_char8_t 201811L [C++20] __cpp_lib_char8_t 201811L [C++20]
*/ */
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/latch.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <latch> // <latch>
// Test the feature test macros defined by <latch> // Test the feature test macros defined by <latch>
/* Constant Value /* Constant Value
__cpp_lib_latch 201907L [C++20] __cpp_lib_latch 201907L [C++20]
*/ */
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/locale.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <locale> // <locale>
// Test the feature test macros defined by <locale> // Test the feature test macros defined by <locale>
/* Constant Value /* Constant Value
__cpp_lib_char8_t 201811L [C++20] __cpp_lib_char8_t 201811L [C++20]
*/ */
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/mutex.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// Test the feature test macros defined by <mutex> // Test the feature test macros defined by <mutex>
/* Constant Value /* Constant Value
__cpp_lib_scoped_lock 201703L [C++17] __cpp_lib_scoped_lock 201703L [C++17]
*/ */
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/ostream.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <ostream> // <ostream>
// Test the feature test macros defined by <ostream> // Test the feature test macros defined by <ostream>
/* Constant Value /* Constant Value
__cpp_lib_char8_t 201811L [C++20] __cpp_lib_char8_t 201811L [C++20]
*/ */
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/regex.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <regex> // <regex>
// Test the feature test macros defined by <regex> // Test the feature test macros defined by <regex>
/* Constant Value /* Constant Value
__cpp_lib_nonmember_container_access 201411L [C++17] __cpp_lib_nonmember_container_access 201411L [C++17]
*/ */
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/semaphore.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <semaphore> // <semaphore>
// Test the feature test macros defined by <semaphore> // Test the feature test macros defined by <semaphore>
/* Constant Value /* Constant Value
__cpp_lib_semaphore 201907L [C++20] __cpp_lib_semaphore 201907L [C++20]
*/ */
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <shared_mutex> // <shared_mutex>
// Test the feature test macros defined by <shared_mutex> // Test the feature test macros defined by <shared_mutex>
/* Constant Value /* Constant Value
__cpp_lib_shared_mutex 201505L [C++17] __cpp_lib_shared_mutex 201505L [C++17]
__cpp_lib_shared_timed_mutex 201402L [C++14] __cpp_lib_shared_timed_mutex 201402L [C++14]
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/stdatomic.h.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <stdatomic.h> // <stdatomic.h>
// Test the feature test macros defined by <stdatomic.h> // Test the feature test macros defined by <stdatomic.h>
/* Constant Value /* Constant Value
__cpp_lib_stdatomic_h 202011L [C++2b] __cpp_lib_stdatomic_h 202011L [C++2b]
*/ */
Show All 39 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/thread.version.compile.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// WARNING: This test was generated by generate_feature_test_macro_components.py // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually. // and should not be edited manually.
// //
// clang-format off // clang-format off
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// Test the feature test macros defined by <thread> // Test the feature test macros defined by <thread>
/* Constant Value /* Constant Value
__cpp_lib_jthread 201911L [C++20] __cpp_lib_jthread 201911L [C++20]
*/ */
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/localization/lit.local.cfg

# <locale> tests are obviously not supported when localization support is disabled # <locale> tests are obviously not supported when localization support is disabled
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp

Show All 9 Lines
// <locale> // <locale>
// template <> class codecvt_byname<wchar_t, char, mbstate_t> // template <> class codecvt_byname<wchar_t, char, mbstate_t>
// explicit codecvt_byname(const char* nm, size_t refs = 0); // explicit codecvt_byname(const char* nm, size_t refs = 0);
// explicit codecvt_byname(const string& nm, size_t refs = 0); // explicit codecvt_byname(const string& nm, size_t refs = 0);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
typedef std::codecvt_byname<wchar_t, char, std::mbstate_t> F; typedef std::codecvt_byname<wchar_t, char, std::mbstate_t> F;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
// explicit codecvt(size_t refs = 0); // explicit codecvt(size_t refs = 0);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
typedef std::codecvt<wchar_t, char, std::mbstate_t> F; typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
Show All 34 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
// bool always_noconv() const throw(); // bool always_noconv() const throw();
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
typedef std::codecvt<wchar_t, char, std::mbstate_t> F; typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**) int main(int, char**)
{ {
std::locale l = std::locale::classic(); std::locale l = std::locale::classic();
const F& f = std::use_facet<F>(l); const F& f = std::use_facet<F>(l);
assert(!f.always_noconv()); assert(!f.always_noconv());
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
// int encoding() const throw(); // int encoding() const throw();
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
typedef std::codecvt<wchar_t, char, std::mbstate_t> F; typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**) int main(int, char**)
{ {
std::locale l = std::locale::classic(); std::locale l = std::locale::classic();
const F& f = std::use_facet<F>(l); const F& f = std::use_facet<F>(l);
assert(f.encoding() == 1); assert(f.encoding() == 1);
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
// result in(stateT& state, // result in(stateT& state,
// const externT* from, const externT* from_end, const externT*& from_next, // const externT* from, const externT* from_end, const externT*& from_next,
// internT* to, internT* to_end, internT*& to_next) const; // internT* to, internT* to_end, internT*& to_next) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include "test_macros.h" #include "test_macros.h"
Show All 23 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
// int length(stateT& state, const externT* from, const externT* from_end, size_t max) const; // int length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
typedef std::codecvt<wchar_t, char, std::mbstate_t> F; typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
Show All 14 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
// int max_length() const throw(); // int max_length() const throw();
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
typedef std::codecvt<wchar_t, char, std::mbstate_t> F; typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
int main(int, char**) int main(int, char**)
{ {
std::locale l = std::locale::classic(); std::locale l = std::locale::classic();
const F& f = std::use_facet<F>(l); const F& f = std::use_facet<F>(l);
assert(f.max_length() == 1); assert(f.max_length() == 1);
return 0; return 0;
} }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
// result out(stateT& state, // result out(stateT& state,
// const internT* from, const internT* from_end, const internT*& from_next, // const internT* from, const internT* from_end, const internT*& from_next,
// externT* to, externT* to_end, externT*& to_next) const; // externT* to, externT* to_end, externT*& to_next) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include <cstring> #include <cstring>
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <> class codecvt<wchar_t, char, mbstate_t> // template <> class codecvt<wchar_t, char, mbstate_t>
// result unshift(stateT& state, // result unshift(stateT& state,
// externT* to, externT* to_end, externT*& to_next) const; // externT* to, externT* to_end, externT*& to_next) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// This is pretty much just an "are you breathing" test // This is pretty much just an "are you breathing" test
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
Show All 16 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp

Show All 14 Lines
// { // {
// public: // public:
// typedef wchar_t intern_type; // typedef wchar_t intern_type;
// typedef char extern_type; // typedef char extern_type;
// typedef mbstate_t state_type; // typedef mbstate_t state_type;
// ... // ...
// }; // };
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
Show All 15 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype_byname; // template <class charT> class ctype_byname;
// bool is(mask m, charT c) const; // bool is(mask m, charT c) const;
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "platform_support.h" // locale name macros #include "platform_support.h" // locale name macros
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype_byname; // template <class charT> class ctype_byname;
// const charT* do_is(const charT* low, const charT* high, mask* vec) const; // const charT* do_is(const charT* low, const charT* high, mask* vec) const;
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_CA.ISO8859-1 // REQUIRES: locale.fr_CA.ISO8859-1
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <locale> // <locale>
// template <class charT> class ctype_byname; // template <class charT> class ctype_byname;
// char narrow(charT c, char dfault) const; // char narrow(charT c, char dfault) const;
#include <locale> #include <locale>
Show All 40 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_CA.ISO8859-1 // REQUIRES: locale.fr_CA.ISO8859-1
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <locale> // <locale>
// template <class charT> class ctype_byname; // template <class charT> class ctype_byname;
// const charT* narrow(const charT* low, const charT*, char dfault, char* to) const; // const charT* narrow(const charT* low, const charT*, char dfault, char* to) const;
#include <locale> #include <locale>
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype_byname; // template <class charT> class ctype_byname;
// const charT* scan_is(mask m, const charT* low, const charT* high) const; // const charT* scan_is(mask m, const charT* low, const charT* high) const;
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype_byname; // template <class charT> class ctype_byname;
// const charT* scan_not(mask m, const charT* low, const charT* high) const; // const charT* scan_not(mask m, const charT* low, const charT* high) const;
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// XFAIL: LIBCXX-AIX-FIXME // XFAIL: LIBCXX-AIX-FIXME
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <locale> // <locale>
// template <class charT> class ctype_byname; // template <class charT> class ctype_byname;
// charT widen(char c) const; // charT widen(char c) const;
// I doubt this test is portable // I doubt this test is portable
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// XFAIL: LIBCXX-AIX-FIXME // XFAIL: LIBCXX-AIX-FIXME
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <locale> // <locale>
// template <class charT> class ctype_byname; // template <class charT> class ctype_byname;
// const char* widen(const char* low, const char* high, charT* to) const; // const char* widen(const char* low, const char* high, charT* to) const;
// I doubt this test is portable // I doubt this test is portable
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// explicit ctype(size_t refs = 0); // explicit ctype(size_t refs = 0);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class C> template <class C>
class my_facet class my_facet
Show All 33 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// bool is(mask m, charT c) const; // bool is(mask m, charT c) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// const charT* do_is(const charT* low, const charT* high, mask* vec) const; // const charT* do_is(const charT* low, const charT* high, mask* vec) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// char narrow(charT c, char dfault) const; // char narrow(charT c, char dfault) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
Show All 15 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// const charT* narrow(const charT* low, const charT*, char dfault, char* to) const; // const charT* narrow(const charT* low, const charT*, char dfault, char* to) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// const charT* scan_is(mask m, const charT* low, const charT* high) const; // const charT* scan_is(mask m, const charT* low, const charT* high) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
Show All 26 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// const charT* scan_not(mask m, const charT* low, const charT* high) const; // const charT* scan_not(mask m, const charT* low, const charT* high) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
Show All 26 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// charT tolower(charT) const; // charT tolower(charT) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
Show All 15 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// const charT* tolower(charT* low, const charT* high) const; // const charT* tolower(charT* low, const charT* high) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
Show All 18 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// charT toupper(charT) const; // charT toupper(charT) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
Show All 15 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// const charT* toupper(charT* low, const charT* high) const; // const charT* toupper(charT* low, const charT* high) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
Show All 18 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// charT widen(char c) const; // charT widen(char c) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
Show All 15 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// template <class charT> class ctype; // template <class charT> class ctype;
// const char* widen(const char* low, const char* high, charT* to) const; // const char* widen(const char* low, const char* high, charT* to) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <string> #include <string>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 20 Lines

libcxx/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp

Show All 11 Lines
// class ctype // class ctype
// : public locale::facet, // : public locale::facet,
// public ctype_base // public ctype_base
// { // {
// public: // public:
// typedef CharT char_type; // typedef CharT char_type;
// }; // };
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
Show All 16 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ru_RU.UTF-8 // REQUIRES: locale.ru_RU.UTF-8
// REQUIRES: locale.zh_CN.UTF-8 // REQUIRES: locale.zh_CN.UTF-8
// <locale> // <locale>
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// NetBSD does not support LC_TIME at the moment // NetBSD does not support LC_TIME at the moment
// XFAIL: netbsd // XFAIL: netbsd
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// XFAIL: LIBCXX-AIX-FIXME // XFAIL: LIBCXX-AIX-FIXME
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ru_RU.UTF-8 // REQUIRES: locale.ru_RU.UTF-8
// REQUIRES: locale.zh_CN.UTF-8 // REQUIRES: locale.zh_CN.UTF-8
// <locale> // <locale>
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.zh_CN.UTF-8 // REQUIRES: locale.zh_CN.UTF-8
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <locale> // <locale>
// class time_get_byname<charT, InputIterator> // class time_get_byname<charT, InputIterator>
// iter_type // iter_type
// get_monthname(iter_type s, iter_type end, ios_base& str, // get_monthname(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// NetBSD does not support LC_TIME at the moment // NetBSD does not support LC_TIME at the moment
// XFAIL: netbsd // XFAIL: netbsd
// XFAIL: LIBCXX-AIX-FIXME // XFAIL: LIBCXX-AIX-FIXME
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ru_RU.UTF-8 // REQUIRES: locale.ru_RU.UTF-8
// REQUIRES: locale.zh_CN.UTF-8 // REQUIRES: locale.zh_CN.UTF-8
// <locale> // <locale>
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ru_RU.UTF-8 // REQUIRES: locale.ru_RU.UTF-8
// REQUIRES: locale.zh_CN.UTF-8 // REQUIRES: locale.zh_CN.UTF-8
// <locale> // <locale>
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ru_RU.UTF-8 // REQUIRES: locale.ru_RU.UTF-8
// REQUIRES: locale.zh_CN.UTF-8 // REQUIRES: locale.zh_CN.UTF-8
// <locale> // <locale>
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ru_RU.UTF-8 // REQUIRES: locale.ru_RU.UTF-8
// REQUIRES: locale.zh_CN.UTF-8 // REQUIRES: locale.zh_CN.UTF-8
// <locale> // <locale>
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// class time_get<charT, InputIterator> // class time_get<charT, InputIterator>
// iter_type // iter_type
// get_date(iter_type s, iter_type end, ios_base& str, // get_date(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef cpp17_input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
Show All 31 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// class time_get<charT, InputIterator> // class time_get<charT, InputIterator>
// iter_type // iter_type
// get_monthname(iter_type s, iter_type end, ios_base& str, // get_monthname(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef cpp17_input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// class time_get<charT, InputIterator> // class time_get<charT, InputIterator>
// iter_type // iter_type
// get_time(iter_type s, iter_type end, ios_base& str, // get_time(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef cpp17_input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// class time_get<charT, InputIterator> // class time_get<charT, InputIterator>
// iter_type // iter_type
// get_weekday(iter_type s, iter_type end, ios_base& str, // get_weekday(iter_type s, iter_type end, ios_base& str,
// ios_base::iostate& err, tm* t) const; // ios_base::iostate& err, tm* t) const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
typedef cpp17_input_iterator<const wchar_t*> I; typedef cpp17_input_iterator<const wchar_t*> I;
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp

Show All 10 Lines
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// Not a portable test // Not a portable test
#include <codecvt> #include <codecvt>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "count_new.h" #include "count_new.h"
Show All 21 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp

Show All 10 Lines
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// Not a portable test // Not a portable test
#include <codecvt> #include <codecvt>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include "count_new.h" #include "count_new.h"
Show All 21 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp

Show All 12 Lines
// wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt, // wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
// state_type state = state_type()); // before C++14 // state_type state = state_type()); // before C++14
// explicit wbuffer_convert(streambuf* bytebuf = nullptr, Codecvt* pcvt = new Codecvt, // explicit wbuffer_convert(streambuf* bytebuf = nullptr, Codecvt* pcvt = new Codecvt,
// state_type state = state_type()); // before C++20 // state_type state = state_type()); // before C++20
// wbuffer_convert() : wbuffer_convert(nullptr) {} // C++20 // wbuffer_convert() : wbuffer_convert(nullptr) {} // C++20
// explicit wbuffer_convert(streambuf* bytebuf, Codecvt* pcvt = new Codecvt, // explicit wbuffer_convert(streambuf* bytebuf, Codecvt* pcvt = new Codecvt,
// state_type state = state_type()); // C++20 // state_type state = state_type()); // C++20
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.h" #include "count_new.h"
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// int_type overflow(int_type c = traits::eof()); // int_type overflow(int_type c = traits::eof());
// This test is not entirely portable // This test is not entirely portable
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <fstream> #include <fstream>
#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/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp

Show All 10 Lines
// <locale> // <locale>
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// int_type pbackfail(int_type c = traits::eof()); // int_type pbackfail(int_type c = traits::eof());
// This test is not entirely portable // This test is not entirely portable
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <fstream> #include <fstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 39 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// streambuf *rdbuf(streambuf *bytebuf); // streambuf *rdbuf(streambuf *bytebuf);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 13 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp

Show All 11 Lines
// pos_type seekoff(off_type off, ios_base::seekdir way, // pos_type seekoff(off_type off, ios_base::seekdir way,
// ios_base::openmode which = ios_base::in | ios_base::out); // ios_base::openmode which = ios_base::in | ios_base::out);
// pos_type seekpos(pos_type sp, // pos_type seekpos(pos_type sp,
// ios_base::openmode which = ios_base::in | ios_base::out); // ios_base::openmode which = ios_base::in | ios_base::out);
// This test is not entirely portable // This test is not entirely portable
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <fstream> #include <fstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 35 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// state_type state() const; // state_type state() const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 11 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <fstream> #include <fstream>
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp

Show All 10 Lines
// <locale> // <locale>
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// int_type underflow(); // int_type underflow();
// This test is not entirely portable // This test is not entirely portable
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <fstream> #include <fstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// size_t converted() const; // size_t converted() const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class CharT, size_t = sizeof(CharT)> template <class CharT, size_t = sizeof(CharT)>
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp

Show All 9 Lines
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(Codecvt* pcvt = new Codecvt); // before C++14 // wstring_convert(Codecvt* pcvt = new Codecvt); // before C++14
// explicit wstring_convert(Codecvt* pcvt = new Codecvt); // before C++20 // explicit wstring_convert(Codecvt* pcvt = new Codecvt); // before C++20
// wstring_convert() : wstring_convert(new Codecvt) {} // C++20 // wstring_convert() : wstring_convert(new Codecvt) {} // C++20
// explicit wstring_convert(Codecvt* pcvt); // C++20 // explicit wstring_convert(Codecvt* pcvt); // C++20
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "test_convertible.h" #include "test_convertible.h"
Show All 32 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(Codecvt* pcvt, state_type state); // wstring_convert(Codecvt* pcvt, state_type state);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
Show All 10 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp

Show All 11 Lines
// <locale> // <locale>
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(wstring_convert const&) = delete; // wstring_convert(wstring_convert const&) = delete;
// wstring_convert& operator=(wstring_convert const&) = delete; // wstring_convert& operator=(wstring_convert const&) = delete;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::codecvt_utf8<wchar_t> Codecvt; typedef std::codecvt_utf8<wchar_t> Codecvt;
typedef std::wstring_convert<Codecvt> Myconv; typedef std::wstring_convert<Codecvt> Myconv;
static_assert(!std::is_copy_constructible<Myconv>::value, ""); static_assert(!std::is_copy_constructible<Myconv>::value, "");
static_assert(!std::is_copy_assignable<Myconv>::value, ""); static_assert(!std::is_copy_assignable<Myconv>::value, "");
return 0; return 0;
} }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(const byte_string& byte_err, // wstring_convert(const byte_string& byte_err,
// const wide_string& wide_err = wide_string()); // const wide_string& wide_err = wide_string());
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp

Show All 9 Lines
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wide_string from_bytes(char byte); // wide_string from_bytes(char byte);
// wide_string from_bytes(const char* ptr); // wide_string from_bytes(const char* ptr);
// wide_string from_bytes(const byte_string& str); // wide_string from_bytes(const byte_string& str);
// wide_string from_bytes(const char* first, const char* last); // wide_string from_bytes(const char* first, const char* last);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class CharT, size_t = sizeof(CharT)> template <class CharT, size_t = sizeof(CharT)>
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// state_type state() const; // state_type state() const;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::codecvt_utf8<wchar_t> Codecvt; typedef std::codecvt_utf8<wchar_t> Codecvt;
typedef std::wstring_convert<Codecvt> Myconv; typedef std::wstring_convert<Codecvt> Myconv;
Myconv myconv; Myconv myconv;
std::mbstate_t s = myconv.state(); std::mbstate_t s = myconv.state();
((void)s); ((void)s);
return 0; return 0;
} }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp

Show All 9 Lines
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// byte_string to_bytes(Elem wchar); // byte_string to_bytes(Elem wchar);
// byte_string to_bytes(const Elem* wptr); // byte_string to_bytes(const Elem* wptr);
// byte_string to_bytes(const wide_string& wstr); // byte_string to_bytes(const wide_string& wstr);
// byte_string to_bytes(const Elem* first, const Elem* last); // byte_string to_bytes(const Elem* first, const Elem* last);
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class CharT, size_t = sizeof(CharT)> template <class CharT, size_t = sizeof(CharT)>
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp

Show All 13 Lines
// class wstring_convert // class wstring_convert
// { // {
// public: // public:
// typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string; // typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string;
// typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string; // typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
// typedef typename Codecvt::state_type state_type; // typedef typename Codecvt::state_type state_type;
// typedef typename wide_string::traits_type::int_type int_type; // typedef typename wide_string::traits_type::int_type int_type;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
Show All 10 Lines

libcxx/test/std/namespace/addressable_functions.sh.cpp

Show All 12 Lines
// a consistent behavior for that across standard modes. // a consistent behavior for that across standard modes.
// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu1.o -DTU1 // RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu1.o -DTU1
// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu2.o -DTU2 // RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu2.o -DTU2
// RUN: %{cxx} %t.tu1.o %t.tu2.o %{flags} %{link_flags} -o %t.exe // RUN: %{cxx} %t.tu1.o %t.tu2.o %{flags} %{link_flags} -o %t.exe
// RUN: %{exec} %t.exe // RUN: %{exec} %t.exe
// The functions checked below come from <iostream> & friends // The functions checked below come from <iostream> & friends
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <cassert> #include <cassert>
#include <ios> #include <ios>
#include <istream> #include <istream>
#include <map> #include <map>
#include <ostream> #include <ostream>
#include <string> #include <string>
#include <utility> #include <utility>
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

libcxx/test/std/numerics/complex.number/complex.ops/stream_input.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <complex> // <complex>
// template<class T, class charT, class traits> // template<class T, class charT, class traits>
// basic_istream<charT, traits>& // basic_istream<charT, traits>&
// operator>>(basic_istream<charT, traits>& is, complex<T>& x); // operator>>(basic_istream<charT, traits>& is, complex<T>& x);
#include <complex> #include <complex>
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

libcxx/test/std/numerics/complex.number/complex.ops/stream_output.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <complex> // <complex>
// template<class T, class charT, class traits> // template<class T, class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& o, const complex<T>& x); // operator<<(basic_ostream<charT, traits>& o, const complex<T>& x);
#include <complex> #include <complex>
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class Engine, size_t p, size_t r> // template<class Engine, size_t p, size_t r>
// class discard_block_engine // class discard_block_engine
// explicit discard_block_engine(result_type s = default_seed); // explicit discard_block_engine(result_type s = default_seed);
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void void
Show All 32 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class Engine, size_t p, size_t r> // template<class Engine, size_t p, size_t r>
// class discard_block_engine // class discard_block_engine
// template<class Sseq> explicit discard_block_engine(Sseq& q); // template<class Sseq> explicit discard_block_engine(Sseq& q);
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void void
Show All 36 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class Engine, size_t p, size_t r> // template<class Engine, size_t p, size_t r>
// class discard_block_engine // class discard_block_engine
// template <class charT, class traits, // template <class charT, class traits,
// class Engine, size_t p, size_t r> // class Engine, size_t p, size_t r>
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class Engine, size_t w, class UIntType> // template<class Engine, size_t w, class UIntType>
// class independent_bits_engine // class independent_bits_engine
// explicit independent_bits_engine(result_type s = default_seed); // explicit independent_bits_engine(result_type s = default_seed);
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void void
Show All 32 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class Engine, size_t w, class UIntType> // template<class Engine, size_t w, class UIntType>
// class independent_bits_engine // class independent_bits_engine
// template<class Sseq> explicit independent_bits_engine(Sseq& q); // template<class Sseq> explicit independent_bits_engine(Sseq& q);
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void void
Show All 36 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class Engine, size_t w, class UIntType> // template<class Engine, size_t w, class UIntType>
// class independent_bits_engine // class independent_bits_engine
// template <class charT, class traits, // template <class charT, class traits,
// class Engine, size_t w, class UIntType> // class Engine, size_t w, class UIntType>
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class Engine, size_t k> // template<class Engine, size_t k>
// class shuffle_order_engine // class shuffle_order_engine
// explicit shuffle_order_engine(result_type s = default_seed); // explicit shuffle_order_engine(result_type s = default_seed);
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void void
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class Engine, size_t k> // template<class Engine, size_t k>
// class shuffle_order_engine // class shuffle_order_engine
// template<class Sseq> explicit shuffle_order_engine(Sseq& q); // template<class Sseq> explicit shuffle_order_engine(Sseq& q);
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void void
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class Engine, size_t k> // template<class Engine, size_t k>
// class shuffle_order_engine // class shuffle_order_engine
// template <class charT, class traits, // template <class charT, class traits,
// class Engine, size_t k> // class Engine, size_t k>
Show All 36 Lines

libcxx/test/std/numerics/rand/rand.device/ctor.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// See https://llvm.org/PR20183 // See https://llvm.org/PR20183
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// The behavior of std::random_device changed on Apple platforms with // The behavior of std::random_device changed on Apple platforms with
// https://llvm.org/D116045. // https://llvm.org/D116045.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11.0|12.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11.0|12.0}}
// UNSUPPORTED: libcpp-has-no-random-device // UNSUPPORTED: no-random-device
// <random> // <random>
// class random_device; // class random_device;
// explicit random_device(const string& token = implementation-defined); // before C++20 // explicit random_device(const string& token = implementation-defined); // before C++20
// random_device() : random_device(implementation-defined) {} // C++20 // random_device() : random_device(implementation-defined) {} // C++20
// explicit random_device(const string& token); // C++20 // explicit random_device(const string& token); // C++20
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.device/entropy.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: libcpp-has-no-random-device // UNSUPPORTED: no-random-device
// <random> // <random>
// class random_device; // class random_device;
// double entropy() const; // double entropy() const;
#include <random> #include <random>
Show All 13 Lines

libcxx/test/std/numerics/rand/rand.device/eval.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: libcpp-has-no-random-device // UNSUPPORTED: no-random-device
// <random> // <random>
// class random_device; // class random_device;
// result_type operator()(); // result_type operator()();
#include <random> #include <random>
Show All 28 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bernoulli/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// class bernoulli_distribution // class bernoulli_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, // operator<<(basic_ostream<charT, traits>& os,
Show All 28 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.PR44847.pass.cpp

Show All 10 Lines
// template<class IntType = int> // template<class IntType = int>
// class binomial_distribution // class binomial_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
// Test the fix for https://llvm.org/PR44847. // Test the fix for https://llvm.org/PR44847.
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <numeric> #include <numeric>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include <sstream> #include <sstream>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class binomial_distribution // class binomial_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.geo/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class geometric_distribution // class geometric_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.negbin/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class negative_binomial_distribution // class negative_binomial_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.cauchy/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class cauchy_distribution // class cauchy_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.chisq/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class chi_squared_distribution // class chi_squared_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.f/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class fisher_f_distribution // class fisher_f_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.lognormal/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class lognormal_distribution // class lognormal_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.normal/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class normal_distribution // class normal_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.t/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class student_t_distribution // class student_t_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.exp/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class exponential_distribution // class exponential_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.extreme/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class extreme_value_distribution // class extreme_value_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.gamma/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class gamma_distribution // class gamma_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.poisson/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class poisson_distribution // class poisson_distribution
// template <class CharT, class Traits, class IntType> // template <class CharT, class Traits, class IntType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.weibull/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class weibull_distribution // class weibull_distribution
// template <class CharT, class Traits, class RealType> // template <class CharT, class Traits, class RealType>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class discrete_distribution // class discrete_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
Show All 30 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.pconst/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class piecewise_constant_distribution // class piecewise_constant_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
Show All 32 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.plinear/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class piecewise_linear_distribution // class piecewise_linear_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
Show All 32 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class _IntType = int> // template<class _IntType = int>
// class uniform_int_distribution // class uniform_int_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.real/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class uniform_real_distribution // class uniform_real_distribution
// template <class charT, class traits> // template <class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
Show All 29 Lines

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp

Show All 10 Lines
// template <class UIntType, UIntType a, UIntType c, UIntType m> // template <class UIntType, UIntType a, UIntType c, UIntType m>
// class linear_congruential_engine; // class linear_congruential_engine;
// explicit linear_congruential_engine(result_type s = default_seed); // before C++20 // explicit linear_congruential_engine(result_type s = default_seed); // before C++20
// linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20 // linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20
// explicit linear_congruential_engine(result_type s); // C++20 // explicit linear_congruential_engine(result_type s); // C++20
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "make_implicit.h" #include "make_implicit.h"
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template <class UIntType, UIntType a, UIntType c, UIntType m> // template <class UIntType, UIntType a, UIntType c, UIntType m>
// class linear_congruential_engine; // class linear_congruential_engine;
// template <class charT, class traits, // template <class charT, class traits,
// class UIntType, UIntType a, UIntType c, UIntType m> // class UIntType, UIntType a, UIntType c, UIntType m>
Show All 32 Lines

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp

Show All 12 Lines
// UIntType b, size_t t, UIntType c, size_t l, UIntType f> // UIntType b, size_t t, UIntType c, size_t l, UIntType f>
// class mersenne_twister_engine; // class mersenne_twister_engine;
// explicit mersenne_twister_engine(result_type s = default_seed); // before C++20 // explicit mersenne_twister_engine(result_type s = default_seed); // before C++20
// mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20 // mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20
// explicit mersenne_twister_engine(result_type s); // C++20 // explicit mersenne_twister_engine(result_type s); // C++20
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "make_implicit.h" #include "make_implicit.h"
▲ Show 20 Lines • Show All 245 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp

Show All 10 Lines
// template <class UIntType, size_t w, size_t n, size_t m, size_t r, // template <class UIntType, size_t w, size_t n, size_t m, size_t r,
// UIntType a, size_t u, UIntType d, size_t s, // UIntType a, size_t u, UIntType d, size_t s,
// UIntType b, size_t t, UIntType c, size_t l, UIntType f> // UIntType b, size_t t, UIntType c, size_t l, UIntType f>
// class mersenne_twister_engine; // class mersenne_twister_engine;
// template<class Sseq> explicit mersenne_twister_engine(Sseq& q); // template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void void
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template <class UIntType, size_t w, size_t n, size_t m, size_t r, // template <class UIntType, size_t w, size_t n, size_t m, size_t r,
// UIntType a, size_t u, UIntType d, size_t s, // UIntType a, size_t u, UIntType d, size_t s,
// UIntType b, size_t t, UIntType c, size_t l, UIntType f> // UIntType b, size_t t, UIntType c, size_t l, UIntType f>
// class mersenne_twister_engine; // class mersenne_twister_engine;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp

Show All 10 Lines
// template<class UIntType, size_t w, size_t s, size_t r> // template<class UIntType, size_t w, size_t s, size_t r>
// class subtract_with_carry_engine; // class subtract_with_carry_engine;
// explicit subtract_with_carry_engine(result_type s = default_seed); // before C++20 // explicit subtract_with_carry_engine(result_type s = default_seed); // before C++20
// subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20 // subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20
// explicit subtract_with_carry_engine(result_type s); // C++20 // explicit subtract_with_carry_engine(result_type s); // C++20
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
#include "make_implicit.h" #include "make_implicit.h"
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class UIntType, size_t w, size_t s, size_t r> // template<class UIntType, size_t w, size_t s, size_t r>
// class subtract_with_carry_engine; // class subtract_with_carry_engine;
// template<class Sseq> explicit subtract_with_carry_engine(Sseq& q); // template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
void void
Show All 36 Lines

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <random> // <random>
// template<class UIntType, size_t w, size_t s, size_t r> // template<class UIntType, size_t w, size_t s, size_t r>
// class subtract_with_carry_engine; // class subtract_with_carry_engine;
// template <class charT, class traits, // template <class charT, class traits,
// class UIntType, size_t w, size_t s, size_t r> // class UIntType, size_t w, size_t s, size_t r>
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/re/lit.local.cfg

# Unfortunately, <regex> uses locales in regex_traits # Unfortunately, <regex> uses locales in regex_traits
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/re/re.syn/wcmatch.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef match_results<const wchar_t*> wcmatch; // typedef match_results<const wchar_t*> wcmatch;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::match_results<const wchar_t*>, std::wcmatch>::value), ""); static_assert((std::is_same<std::match_results<const wchar_t*>, std::wcmatch>::value), "");
return 0; return 0;
} }

libcxx/test/std/re/re.syn/wcregex_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef regex_iterator<const wchar_t*> wcregex_iterator; // typedef regex_iterator<const wchar_t*> wcregex_iterator;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::regex_iterator<const wchar_t*>, std::wcregex_iterator>::value), ""); static_assert((std::is_same<std::regex_iterator<const wchar_t*>, std::wcregex_iterator>::value), "");
return 0; return 0;
} }

libcxx/test/std/re/re.syn/wcregex_token_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator; // typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::regex_token_iterator<const wchar_t*>, std::wcregex_token_iterator>::value), ""); static_assert((std::is_same<std::regex_token_iterator<const wchar_t*>, std::wcregex_token_iterator>::value), "");
return 0; return 0;
} }

libcxx/test/std/re/re.syn/wcsub_match.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef sub_match<const wchar_t*> wcsub_match; // typedef sub_match<const wchar_t*> wcsub_match;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::sub_match<const wchar_t*>, std::wcsub_match>::value), ""); static_assert((std::is_same<std::sub_match<const wchar_t*>, std::wcsub_match>::value), "");
return 0; return 0;
} }

libcxx/test/std/re/re.syn/wregex.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef basic_regex<wchar_t> wregex; // typedef basic_regex<wchar_t> wregex;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::basic_regex<wchar_t>, std::wregex>::value), ""); static_assert((std::is_same<std::basic_regex<wchar_t>, std::wregex>::value), "");
return 0; return 0;
} }

libcxx/test/std/re/re.syn/wsmatch.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef match_results<wstring::const_iterator> wsmatch; // typedef match_results<wstring::const_iterator> wsmatch;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::match_results<std::wstring::const_iterator>, std::wsmatch>::value), ""); static_assert((std::is_same<std::match_results<std::wstring::const_iterator>, std::wsmatch>::value), "");
return 0; return 0;
} }

libcxx/test/std/re/re.syn/wsregex_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef regex_iterator<wstring::const_iterator> wsregex_iterator; // typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::regex_iterator<std::wstring::const_iterator>, std::wsregex_iterator>::value), ""); static_assert((std::is_same<std::regex_iterator<std::wstring::const_iterator>, std::wsregex_iterator>::value), "");
return 0; return 0;
} }

libcxx/test/std/re/re.syn/wsregex_token_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; // typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::regex_token_iterator<std::wstring::const_iterator>, std::wsregex_token_iterator>::value), ""); static_assert((std::is_same<std::regex_token_iterator<std::wstring::const_iterator>, std::wsregex_token_iterator>::value), "");
return 0; return 0;
} }

libcxx/test/std/re/re.syn/wssub_match.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <regex> // <regex>
// typedef sub_match<wstring::const_iterator> wssub_match; // typedef sub_match<wstring::const_iterator> wssub_match;
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <regex> #include <regex>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::sub_match<std::wstring::const_iterator>, std::wssub_match>::value), ""); static_assert((std::is_same<std::sub_match<std::wstring::const_iterator>, std::wssub_match>::value), "");
return 0; return 0;
} }

libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.explicit_instantiation.sh.cpp

Show All 9 Lines
// character type and traits and then use `shrink_to_fit`. In particular, this is // character type and traits and then use `shrink_to_fit`. In particular, this is
// a regression test for the bug that was reported at https://stackoverflow.com/q/69520633/627587 // a regression test for the bug that was reported at https://stackoverflow.com/q/69520633/627587
// and https://seedcentral.apple.com/sm/feedback_collector/radar/85053279. // and https://seedcentral.apple.com/sm/feedback_collector/radar/85053279.
// RUN: %{cxx} %{flags} %{compile_flags} %s %{link_flags} -DTU1 -c -o %t.tu1.o // RUN: %{cxx} %{flags} %{compile_flags} %s %{link_flags} -DTU1 -c -o %t.tu1.o
// RUN: %{cxx} %{flags} %{compile_flags} %s %{link_flags} -DTU2 -c -o %t.tu2.o // RUN: %{cxx} %{flags} %{compile_flags} %s %{link_flags} -DTU2 -c -o %t.tu2.o
// RUN: %{cxx} %{flags} %t.tu1.o %t.tu2.o %{link_flags} -o %t.exe // RUN: %{cxx} %{flags} %t.tu1.o %t.tu2.o %{link_flags} -o %t.exe
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
#include <cstdint> #include <cstdint>
#include <ios> #include <ios>
#include <string> #include <string>
typedef std::uint16_t char16; typedef std::uint16_t char16;
struct string16_char_traits { struct string16_char_traits {
Show All 33 Lines

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/lit.local.cfg

# These std::string functions require iostreams, which requires localization # These std::string functions require iostreams, which requires localization
if 'libcpp-has-no-localization' in config.available_features: if 'no-localization' in config.available_features:
config.unsupported = True config.unsupported = True

libcxx/test/std/strings/c.strings/cwchar.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <cwchar> // <cwchar>
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <cwchar> #include <cwchar>
#include <ctime> #include <ctime>
#include <cstdarg> #include <cstdarg>
#include <cstdio> #include <cstdio>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libcxx/test/std/strings/c.strings/cwctype.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <cwctype> // <cwctype>
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
#include <cwctype> #include <cwctype>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#ifndef WEOF #ifndef WEOF
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static void assign(char_type& c1, const char_type& c2); // static void assign(char_type& c1, const char_type& c2);
// constexpr in C++17 // constexpr in C++17
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
constexpr bool test_constexpr() constexpr bool test_constexpr()
Show All 19 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static char_type* assign(char_type* s, size_t n, char_type a); // static char_type* assign(char_type* s, size_t n, char_type a);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 20 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static int compare(const char_type* s1, const char_type* s2, size_t n); // static int compare(const char_type* s1, const char_type* s2, size_t n);
// constexpr in C++17 // constexpr in C++17
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
constexpr bool test_constexpr() constexpr bool test_constexpr()
Show All 36 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static char_type* copy(char_type* s1, const char_type* s2, size_t n); // static char_type* copy(char_type* s1, const char_type* s2, size_t n);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 22 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static constexpr int_type eof(); // static constexpr int_type eof();
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
assert(std::char_traits<wchar_t>::eof() == WEOF); assert(std::char_traits<wchar_t>::eof() == WEOF);
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static constexpr bool eq(char_type c1, char_type c2); // static constexpr bool eq(char_type c1, char_type c2);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
assert(std::char_traits<wchar_t>::eq(L'a', L'a')); assert(std::char_traits<wchar_t>::eq(L'a', L'a'));
assert(!std::char_traits<wchar_t>::eq(L'a', L'A')); assert(!std::char_traits<wchar_t>::eq(L'a', L'A'));
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static constexpr bool eq_int_type(int_type c1, int_type c2); // static constexpr bool eq_int_type(int_type c1, int_type c2);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
assert( std::char_traits<wchar_t>::eq_int_type(L'a', L'a')); assert( std::char_traits<wchar_t>::eq_int_type(L'a', L'a'));
assert(!std::char_traits<wchar_t>::eq_int_type(L'a', L'A')); assert(!std::char_traits<wchar_t>::eq_int_type(L'a', L'A'));
assert(!std::char_traits<wchar_t>::eq_int_type(std::char_traits<wchar_t>::eof(), L'A')); assert(!std::char_traits<wchar_t>::eq_int_type(std::char_traits<wchar_t>::eof(), L'A'));
assert( std::char_traits<wchar_t>::eq_int_type(std::char_traits<wchar_t>::eof(), assert( std::char_traits<wchar_t>::eq_int_type(std::char_traits<wchar_t>::eof(),
std::char_traits<wchar_t>::eof())); std::char_traits<wchar_t>::eof()));
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static const char_type* find(const char_type* s, size_t n, const char_type& a); // static const char_type* find(const char_type* s, size_t n, const char_type& a);
// constexpr in C++17 // constexpr in C++17
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
constexpr bool test_constexpr() constexpr bool test_constexpr()
Show All 25 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static size_t length(const char_type* s); // static size_t length(const char_type* s);
// constexpr in C++17 // constexpr in C++17
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
constexpr bool test_constexpr() constexpr bool test_constexpr()
Show All 20 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static constexpr bool lt(char_type c1, char_type c2); // static constexpr bool lt(char_type c1, char_type c2);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
Show All 15 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <string> // <string>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static char_type* move(char_type* s1, const char_type* s2, size_t n); // static char_type* move(char_type* s1, const char_type* s2, size_t n);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
Show All 26 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static constexpr int_type not_eof(int_type c); // static constexpr int_type not_eof(int_type c);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
assert(std::char_traits<wchar_t>::not_eof(L'a') == L'a'); assert(std::char_traits<wchar_t>::not_eof(L'a') == L'a');
assert(std::char_traits<wchar_t>::not_eof(L'A') == L'A'); assert(std::char_traits<wchar_t>::not_eof(L'A') == L'A');
assert(std::char_traits<wchar_t>::not_eof(0) == 0); assert(std::char_traits<wchar_t>::not_eof(0) == 0);
assert(std::char_traits<wchar_t>::not_eof(std::char_traits<wchar_t>::eof()) != assert(std::char_traits<wchar_t>::not_eof(std::char_traits<wchar_t>::eof()) !=
std::char_traits<wchar_t>::eof()); std::char_traits<wchar_t>::eof());
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static constexpr char_type to_char_type(int_type c); // static constexpr char_type to_char_type(int_type c);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
assert(std::char_traits<wchar_t>::to_char_type(L'a') == L'a'); assert(std::char_traits<wchar_t>::to_char_type(L'a') == L'a');
assert(std::char_traits<wchar_t>::to_char_type(L'A') == L'A'); assert(std::char_traits<wchar_t>::to_char_type(L'A') == L'A');
assert(std::char_traits<wchar_t>::to_char_type(0) == 0); assert(std::char_traits<wchar_t>::to_char_type(0) == 0);
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.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>
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// static constexpr int_type to_int_type(char_type c); // static constexpr int_type to_int_type(char_type c);
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
assert(std::char_traits<wchar_t>::to_int_type(L'a') == L'a'); assert(std::char_traits<wchar_t>::to_int_type(L'a') == L'a');
assert(std::char_traits<wchar_t>::to_int_type(L'A') == L'A'); assert(std::char_traits<wchar_t>::to_int_type(L'A') == L'A');
assert(std::char_traits<wchar_t>::to_int_type(0) == 0); assert(std::char_traits<wchar_t>::to_int_type(0) == 0);
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp

Show All 10 Lines
// template<> struct char_traits<wchar_t> // template<> struct char_traits<wchar_t>
// typedef wchar_t char_type; // typedef wchar_t char_type;
// typedef int int_type; // typedef int int_type;
// typedef streamoff off_type; // typedef streamoff off_type;
// typedef streampos pos_type; // typedef streampos pos_type;
// typedef mbstate_t state_type; // typedef mbstate_t state_type;
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert((std::is_same<std::char_traits<wchar_t>::char_type, wchar_t>::value), ""); static_assert((std::is_same<std::char_traits<wchar_t>::char_type, wchar_t>::value), "");
static_assert((std::is_same<std::char_traits<wchar_t>::int_type, std::wint_t>::value), ""); static_assert((std::is_same<std::char_traits<wchar_t>::int_type, std::wint_t>::value), "");
static_assert((std::is_same<std::char_traits<wchar_t>::off_type, std::streamoff>::value), ""); static_assert((std::is_same<std::char_traits<wchar_t>::off_type, std::streamoff>::value), "");
static_assert((std::is_same<std::char_traits<wchar_t>::pos_type, std::wstreampos>::value), ""); static_assert((std::is_same<std::char_traits<wchar_t>::pos_type, std::wstreampos>::value), "");
static_assert((std::is_same<std::char_traits<wchar_t>::state_type, std::mbstate_t>::value), ""); static_assert((std::is_same<std::char_traits<wchar_t>::state_type, std::mbstate_t>::value), "");
return 0; return 0;
} }

libcxx/test/std/strings/string.conversions/to_wstring.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: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <string> // <string>
// wstring to_wstring(int val); // wstring to_wstring(int val);
// wstring to_wstring(unsigned val); // wstring to_wstring(unsigned val);
// wstring to_wstring(long val); // wstring to_wstring(long val);
// wstring to_wstring(unsigned long val); // wstring to_wstring(unsigned long val);
// wstring to_wstring(long long val); // wstring to_wstring(long long val);
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.io/stream_insert.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <string_view> // <string_view>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, // operator<<(basic_ostream<charT, traits>& os,
// const basic_string_view<charT,traits> str); // const basic_string_view<charT,traits> str);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/string.view.nonmem/quoted.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, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <iomanip> // <iomanip>
// quoted // quoted
#include <iomanip> #include <iomanip>
#include <sstream> #include <sstream>
#include <string_view> #include <string_view>
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.async/async.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// template <class F, class... Args> // template <class F, class... Args>
// future<typename result_of<F(Args...)>::type> // future<typename result_of<F(Args...)>::type>
// async(F&& f, Args&&... args); // async(F&& f, Args&&... args);
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.async/async.verify.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// <future> // <future>
// template <class F, class... Args> // template <class F, class... Args>
// future<typename result_of<F(Args...)>::type> // future<typename result_of<F(Args...)>::type>
// async(F&& f, Args&&... args); // async(F&& f, Args&&... args);
Show All 21 Lines

libcxx/test/std/thread/futures/futures.async/async_race.38682.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// There's currently no release of OS X whose dylib contains the patch for // There's currently no release of OS X whose dylib contains the patch for
// PR38682. Since the fix for future<void> is in the dylib, this test may fail. // PR38682. Since the fix for future<void> is in the dylib, this test may fail.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// This test is designed to cause and allow TSAN to detect a race condition // This test is designed to cause and allow TSAN to detect a race condition
// in std::async, as reported in https://llvm.org/PR38682. // in std::async, as reported in https://llvm.org/PR38682.
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.async/async_race.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// template <class F, class... Args> // template <class F, class... Args>
// future<typename result_of<F(Args...)>::type> // future<typename result_of<F(Args...)>::type>
// async(F&& f, Args&&... args); // async(F&& f, Args&&... args);
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.errors/default_error_condition.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// const error_category& future_category(); // const error_category& future_category();
// virtual error_condition default_error_condition(int ev) const; // virtual error_condition default_error_condition(int ev) const;
#include <future> #include <future>
Show All 13 Lines

libcxx/test/std/thread/futures/futures.errors/equivalent_error_code_int.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// const error_category& future_category(); // const error_category& future_category();
// virtual bool equivalent(const error_code& code, int condition) const; // virtual bool equivalent(const error_code& code, int condition) const;
#include <future> #include <future>
Show All 12 Lines

libcxx/test/std/thread/futures/futures.errors/equivalent_int_error_condition.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// const error_category& future_category(); // const error_category& future_category();
// virtual bool equivalent(int code, const error_condition& condition) const; // virtual bool equivalent(int code, const error_condition& condition) const;
#include <future> #include <future>
Show All 13 Lines

libcxx/test/std/thread/futures/futures.errors/future_category.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// const error_category& future_category(); // const error_category& future_category();
#include <future> #include <future>
#include <cstring> #include <cstring>
#include <cassert> #include <cassert>
Show All 10 Lines

libcxx/test/std/thread/futures/futures.errors/make_error_code.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class error_code // class error_code
// error_code make_error_code(future_errc e); // error_code make_error_code(future_errc e);
#include <future> #include <future>
Show All 14 Lines

libcxx/test/std/thread/futures/futures.errors/make_error_condition.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class error_condition // class error_condition
// error_condition make_error_condition(future_errc e); // error_condition make_error_condition(future_errc e);
#include <future> #include <future>
Show All 16 Lines

libcxx/test/std/thread/futures/futures.future_error/code.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class future_error // class future_error
// future_error(error_code __ec); // exposition only // future_error(error_code __ec); // exposition only
// explicit future_error(future_errc _Ev) : __ec_(make_error_code(_Ev)) {} // C++17 // explicit future_error(future_errc _Ev) : __ec_(make_error_code(_Ev)) {} // C++17
// const error_code& code() const throw(); // const error_code& code() const throw();
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.future_error/types.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class future_error : public logic_error {...}; // class future_error : public logic_error {...};
#include <future> #include <future>
#include <type_traits> #include <type_traits>
Show All 9 Lines

libcxx/test/std/thread/futures/futures.future_error/what.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// LWG 2056 changed the values of future_errc, so if we're using new headers // LWG 2056 changed the values of future_errc, so if we're using new headers
// with an old library we'll get incorrect messages. // with an old library we'll get incorrect messages.
// //
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <future> // <future>
Show All 34 Lines

libcxx/test/std/thread/futures/futures.overview/future_errc.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// Libc++'s enum class emulation does not allow static_cast<Enum>(0) to work. // Libc++'s enum class emulation does not allow static_cast<Enum>(0) to work.
// <future> // <future>
// enum class future_errc // enum class future_errc
// { // {
Show All 26 Lines

libcxx/test/std/thread/futures/futures.overview/future_status.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// enum class future_status // enum class future_status
// { // {
// ready, // ready,
// timeout, // timeout,
// deferred // deferred
Show All 14 Lines

libcxx/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// template <> struct is_error_code_enum<future_errc> : public true_type {}; // template <> struct is_error_code_enum<future_errc> : public true_type {};
#include <future> #include <future>
#include "test_macros.h" #include "test_macros.h"
Show All 9 Lines

libcxx/test/std/thread/futures/futures.overview/launch.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// enum class launch // enum class launch
// { // {
// async = 1, // async = 1,
// deferred = 2, // deferred = 2,
// any = async | deferred /* EXTENSION */ // any = async | deferred /* EXTENSION */
Show All 31 Lines

libcxx/test/std/thread/futures/futures.promise/alloc_ctor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// template <class Allocator> // template <class Allocator>
// promise(allocator_arg_t, const Allocator& a); // promise(allocator_arg_t, const Allocator& a);
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.promise/copy_assign.verify.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class promise<R> // class promise<R>
// promise& operator=(const promise& rhs) = delete; // promise& operator=(const promise& rhs) = delete;
#include <future> #include <future>
Show All 20 Lines

libcxx/test/std/thread/futures/futures.promise/copy_ctor.verify.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class promise<R> // class promise<R>
// promise(const promise&) = delete; // promise(const promise&) = delete;
#include <future> #include <future>
Show All 20 Lines

libcxx/test/std/thread/futures/futures.promise/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// promise(); // promise();
Show All 25 Lines

libcxx/test/std/thread/futures/futures.promise/dtor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// ~promise(); // ~promise();
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.promise/get_future.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// future<R> get_future(); // future<R> get_future();
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.promise/move_assign.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// promise& operator=(promise&& rhs); // promise& operator=(promise&& rhs);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.promise/move_ctor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// promise(promise&& rhs); // promise(promise&& rhs);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.promise/set_exception.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: no-exceptions // UNSUPPORTED: no-exceptions
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void set_exception(exception_ptr p); // void set_exception(exception_ptr p);
Show All 34 Lines

libcxx/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.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: no-exceptions // UNSUPPORTED: no-exceptions
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void promise::set_exception_at_thread_exit(exception_ptr p); // void promise::set_exception_at_thread_exit(exception_ptr p);
Show All 31 Lines

libcxx/test/std/thread/futures/futures.promise/set_lvalue.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void promise<R&>::set_value(R& r); // void promise<R&>::set_value(R& r);
Show All 32 Lines

libcxx/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void promise<R&>::set_value_at_thread_exit(R& r); // void promise<R&>::set_value_at_thread_exit(R& r);
Show All 26 Lines

libcxx/test/std/thread/futures/futures.promise/set_rvalue.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
// UNSUPPORTED: libcpp-has-no-threads, no-exceptions // UNSUPPORTED: no-threads, no-exceptions
// <future> // <future>
// class promise<R> // class promise<R>
// void promise::set_value(R&& r); // void promise::set_value(R&& r);
#include <future> #include <future>
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.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: libcpp-has-no-threads, c++03 // UNSUPPORTED: no-threads, c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void promise::set_value_at_thread_exit(R&& r); // void promise::set_value_at_thread_exit(R&& r);
#include <future> #include <future>
Show All 22 Lines

libcxx/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void promise::set_value_at_thread_exit(const R& r); // void promise::set_value_at_thread_exit(const R& r);
Show All 23 Lines

libcxx/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void promise<void>::set_value_at_thread_exit(); // void promise<void>::set_value_at_thread_exit();
Show All 27 Lines

libcxx/test/std/thread/futures/futures.promise/set_value_const.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void promise::set_value(const R& r); // void promise::set_value(const R& r);
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.promise/set_value_void.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: no-exceptions // UNSUPPORTED: no-exceptions
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void promise<void>::set_value(); // void promise<void>::set_value();
Show All 26 Lines

libcxx/test/std/thread/futures/futures.promise/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class promise<R> // class promise<R>
// void swap(promise& other); // void swap(promise& other);
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.promise/uses_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class promise<R> // class promise<R>
// template <class R, class Alloc> // template <class R, class Alloc>
// struct uses_allocator<promise<R>, Alloc> // struct uses_allocator<promise<R>, Alloc>
// : true_type { }; // : true_type { };
Show All 13 Lines

libcxx/test/std/thread/futures/futures.shared_future/copy_assign.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// shared_future& operator=(const shared_future& rhs); // shared_future& operator=(const shared_future& rhs);
// noexcept in C++17 // noexcept in C++17
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/copy_ctor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// shared_future(const shared_future& rhs); // shared_future(const shared_future& rhs);
// noexcept in C++17 // noexcept in C++17
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/ctor_future.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// shared_future(future<R>&& rhs); // shared_future(future<R>&& rhs);
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// shared_future(); // shared_future();
#include <future> #include <future>
Show All 21 Lines

libcxx/test/std/thread/futures/futures.shared_future/dtor.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: no-exceptions // UNSUPPORTED: no-exceptions
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// ~shared_future(); // ~shared_future();
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/get.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// const R& shared_future::get(); // const R& shared_future::get();
// R& shared_future<R&>::get(); // R& shared_future<R&>::get();
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/move_assign.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// shared_future& operator=(shared_future&& rhs); // shared_future& operator=(shared_future&& rhs);
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/move_ctor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// shared_future(shared_future&& rhs); // shared_future(shared_future&& rhs);
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/wait.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// void wait() const; // void wait() const;
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/wait_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// template <class Rep, class Period> // template <class Rep, class Period>
// future_status // future_status
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.shared_future/wait_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// template <class Clock, class Duration> // template <class Clock, class Duration>
// future_status // future_status
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// packaged_task& operator=(packaged_task&) = delete; // packaged_task& operator=(packaged_task&) = delete;
Show All 11 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/assign_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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// packaged_task& operator=(packaged_task&& other); // packaged_task& operator=(packaged_task&& other);
Show All 37 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// template <class F> // template <class F>
// packaged_task(F&& f); // packaged_task(F&& f);
// These constructors shall not participate in overload resolution if // These constructors shall not participate in overload resolution if
Show All 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor2.compile.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// template <class F, class Allocator> // template <class F, class Allocator>
// packaged_task(allocator_arg_t, const Allocator& a, F&& f); // packaged_task(allocator_arg_t, const Allocator& a, F&& f);
// These constructors shall not participate in overload resolution if // These constructors shall not participate in overload resolution if
// decay<F>::type is the same type as std::packaged_task<R(ArgTypes...)>. // decay<F>::type is the same type as std::packaged_task<R(ArgTypes...)>.
Show All 24 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// packaged_task(packaged_task&) = delete; // packaged_task(packaged_task&) = delete;
Show All 12 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// packaged_task(); // packaged_task();
Show All 14 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_func.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// template <class F> // template <class F>
// explicit packaged_task(F&& f); // explicit packaged_task(F&& f);
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_func_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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// packaged_task allocator support was removed in C++17 (LWG 2921) // packaged_task allocator support was removed in C++17 (LWG 2921)
// REQUIRES: c++11 || c++14 // REQUIRES: c++11 || c++14
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/ctor_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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// packaged_task(packaged_task&& other); // packaged_task(packaged_task&& other);
Show All 35 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/dtor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// ~packaged_task(); // ~packaged_task();
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/get_future.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// future<R> get_future(); // future<R> get_future();
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// void make_ready_at_thread_exit(ArgTypes... args); // void make_ready_at_thread_exit(ArgTypes... args);
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/operator.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// void operator()(ArgTypes... args); // void operator()(ArgTypes... args);
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/reset.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// void reset(); // void reset();
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.members/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// void swap(packaged_task& other); // void swap(packaged_task& other);
Show All 37 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.nonmembers/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
// template <class R, class... ArgTypes> // template <class R, class... ArgTypes>
// void // void
Show All 39 Lines

libcxx/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.compile.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// packaged_task allocator support was removed in C++17 (LWG 2976) // packaged_task allocator support was removed in C++17 (LWG 2976)
// REQUIRES: c++11 || c++14 // REQUIRES: c++11 || c++14
// <future> // <future>
// class packaged_task<R(ArgTypes...)> // class packaged_task<R(ArgTypes...)>
Show All 9 Lines

libcxx/test/std/thread/futures/futures.unique_future/copy_assign.verify.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class future<R> // class future<R>
// future& operator=(const future&) = delete; // future& operator=(const future&) = delete;
#include <future> #include <future>
Show All 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/copy_ctor.verify.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class future<R> // class future<R>
// future(const future&) = delete; // future(const future&) = delete;
#include <future> #include <future>
Show All 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <future> // <future>
// class future<R> // class future<R>
// future(); // future();
#include <future> #include <future>
Show All 21 Lines

libcxx/test/std/thread/futures/futures.unique_future/dtor.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: no-exceptions // UNSUPPORTED: no-exceptions
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class future<R> // class future<R>
// ~future(); // ~future();
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/get.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class future<R> // class future<R>
// R future::get(); // R future::get();
// R& future<R&>::get(); // R& future<R&>::get();
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/move_assign.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: libcpp-has-no-threads, c++03 // UNSUPPORTED: no-threads, c++03
// <future> // <future>
// class future<R> // class future<R>
// future& operator=(future&& rhs); // future& operator=(future&& rhs);
#include <future> #include <future>
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/move_ctor.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: libcpp-has-no-threads, c++03 // UNSUPPORTED: no-threads, c++03
// <future> // <future>
// class future<R> // class future<R>
// future(future&& rhs); // future(future&& rhs);
#include <future> #include <future>
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/share.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class future<R> // class future<R>
// shared_future<R> share() &&; // shared_future<R> share() &&;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/wait.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class future<R> // class future<R>
// void wait() const; // void wait() const;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/wait_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// ALLOW_RETRIES: 3 // ALLOW_RETRIES: 3
// <future> // <future>
// class future<R> // class future<R>
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/test/std/thread/futures/futures.unique_future/wait_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <future> // <future>
// class future<R> // class future<R>
// template <class Clock, class Duration> // template <class Clock, class Duration>
// future_status // future_status
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

libcxx/test/std/thread/macro.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// #define __STDCPP_THREADS__ 1 // #define __STDCPP_THREADS__ 1
#include <thread> #include <thread>
#include "test_macros.h" #include "test_macros.h"
Show All 11 Lines

libcxx/test/std/thread/thread.barrier/arrive.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <barrier> // <barrier>
#include <barrier> #include <barrier>
Show All 20 Lines

libcxx/test/std/thread/thread.barrier/arrive_and_drop.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <barrier> // <barrier>
#include <barrier> #include <barrier>
Show All 19 Lines

libcxx/test/std/thread/thread.barrier/arrive_and_wait.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <barrier> // <barrier>
#include <barrier> #include <barrier>
Show All 19 Lines

libcxx/test/std/thread/thread.barrier/completion.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <barrier> // <barrier>
#include <barrier> #include <barrier>
Show All 24 Lines

libcxx/test/std/thread/thread.barrier/max.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <barrier> // <barrier>
#include <barrier> #include <barrier>
#include <thread> #include <thread>
#include <cassert> #include <cassert>
Show All 9 Lines

libcxx/test/std/thread/thread.condition/cv_status.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// enum class cv_status { no_timeout, timeout }; // enum class cv_status { no_timeout, timeout };
#include <condition_variable> #include <condition_variable>
#include <cassert> #include <cassert>
Show All 9 Lines

libcxx/test/std/thread/thread.condition/notify_all_at_thread_exit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// notify_all_at_thread_exit(...) requires move semantics to transfer the // notify_all_at_thread_exit(...) requires move semantics to transfer the
// unique_lock. // unique_lock.
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <condition_variable> // <condition_variable>
// void // void
Show All 36 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// condition_variable(); // condition_variable();
#include <condition_variable> #include <condition_variable>
Show All 11 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/destructor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// ~condition_variable(); // ~condition_variable();
#include <condition_variable> #include <condition_variable>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/notify_all.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// void notify_all(); // void notify_all();
#include <condition_variable> #include <condition_variable>
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/notify_one.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// void notify_one(); // void notify_one();
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// void wait(unique_lock<mutex>& lock); // void wait(unique_lock<mutex>& lock);
#include <condition_variable> #include <condition_variable>
Show All 39 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// template <class Rep, class Period> // template <class Rep, class Period>
// cv_status // cv_status
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// template <class Rep, class Period, class Predicate> // template <class Rep, class Period, class Predicate>
// bool // bool
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// template <class Predicate> // template <class Predicate>
// void wait(unique_lock<mutex>& lock, Predicate pred); // void wait(unique_lock<mutex>& lock, Predicate pred);
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// cv_status // cv_status
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// template <class Clock, class Duration, class Predicate> // template <class Clock, class Duration, class Predicate>
// bool // bool
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// condition_variable_any(); // condition_variable_any();
#include <condition_variable> #include <condition_variable>
Show All 10 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/destructor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// ~condition_variable_any(); // ~condition_variable_any();
#include <condition_variable> #include <condition_variable>
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// void notify_all(); // void notify_all();
#include <condition_variable> #include <condition_variable>
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// void notify_one(); // void notify_one();
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// template <class Lock> // template <class Lock>
// void wait(Lock& lock); // void wait(Lock& lock);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// template <class Lock, class Rep, class Period> // template <class Lock, class Rep, class Period>
// cv_status // cv_status
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// template <class Lock, class Rep, class Period, class Predicate> // template <class Lock, class Rep, class Period, class Predicate>
// bool // bool
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// template <class Lock, class Predicate> // template <class Lock, class Predicate>
// void wait(Lock& lock, Predicate pred); // void wait(Lock& lock, Predicate pred);
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.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: no-exceptions // UNSUPPORTED: no-exceptions
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// RUN: %{build} // RUN: %{build}
// RUN: %{run} 1 // RUN: %{run} 1
// RUN: %{run} 2 // RUN: %{run} 2
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// template <class Lock, class Clock, class Duration> // template <class Lock, class Clock, class Duration>
// cv_status // cv_status
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// template <class Lock, class Duration, class Predicate> // template <class Lock, class Duration, class Predicate>
// bool // bool
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.latch/arrive_and_wait.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <latch> // <latch>
#include <latch> #include <latch>
Show All 17 Lines

libcxx/test/std/thread/thread.latch/count_down.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <latch> // <latch>
#include <latch> #include <latch>
Show All 18 Lines

libcxx/test/std/thread/thread.latch/max.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <latch> // <latch>
#include <latch> #include <latch>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
static_assert(std::latch::max() > 0, ""); static_assert(std::latch::max() > 0, "");
return 0; return 0;
} }

libcxx/test/std/thread/thread.latch/try_wait.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <latch> // <latch>
#include <latch> #include <latch>
Show All 14 Lines

libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// This test hangs forever when built against libstdc++ (Oct 2016). // This test hangs forever when built against libstdc++ (Oct 2016).
// UNSUPPORTED: stdlib=libstdc++ // UNSUPPORTED: stdlib=libstdc++
// This test isn't quite standards-conforming: it's testing our specific // This test isn't quite standards-conforming: it's testing our specific
// algorithm, where when lx.try_lock() fails we start the next attempt // algorithm, where when lx.try_lock() fails we start the next attempt
// with an unconditional lx.lock(). Thus our algorithm can handle a list // with an unconditional lx.lock(). Thus our algorithm can handle a list
// of mutexes where at-most-one of them is of the evil type `class L1`, // of mutexes where at-most-one of them is of the evil type `class L1`,
▲ Show 20 Lines • Show All 510 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class L1, class L2, class... L3> // template <class L1, class L2, class... L3>
// int try_lock(L1&, L2&, L3&...); // int try_lock(L1&, L2&, L3&...);
#include <mutex> #include <mutex>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 510 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class lock_guard; // template <class Mutex> class lock_guard;
// lock_guard(mutex_type& m, adopt_lock_t); // lock_guard(mutex_type& m, adopt_lock_t);
#include <mutex> #include <mutex>
Show All 25 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class lock_guard; // template <class Mutex> class lock_guard;
// explicit lock_guard(mutex_type& m); // explicit lock_guard(mutex_type& m);
#include <mutex> #include <mutex>
int main(int, char**) int main(int, char**)
{ {
std::mutex m; std::mutex m;
std::lock_guard<std::mutex> lg = m; // expected-error{{no viable conversion}} std::lock_guard<std::mutex> lg = m; // expected-error{{no viable conversion}}
return 0; return 0;
} }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class lock_guard; // template <class Mutex> class lock_guard;
// explicit lock_guard(mutex_type& m); // explicit lock_guard(mutex_type& m);
// template<class _Mutex> lock_guard(lock_guard<_Mutex>) // template<class _Mutex> lock_guard(lock_guard<_Mutex>)
Show All 32 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> // template <class Mutex>
// class lock_guard // class lock_guard
// { // {
// public: // public:
// typedef Mutex mutex_type; // typedef Mutex mutex_type;
Show All 15 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// <mutex> // <mutex>
// template <class ...Mutex> class scoped_lock; // template <class ...Mutex> class scoped_lock;
// scoped_lock(adopt_lock_t, Mutex&...); // scoped_lock(adopt_lock_t, Mutex&...);
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// <mutex> // <mutex>
// template <class ...Mutex> class scoped_lock; // template <class ...Mutex> class scoped_lock;
// scoped_lock& operator=(scoped_lock const&) = delete; // scoped_lock& operator=(scoped_lock const&) = delete;
Show All 34 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// <mutex> // <mutex>
// template <class ...Mutex> class scoped_lock; // template <class ...Mutex> class scoped_lock;
// scoped_lock(scoped_lock const&) = delete; // scoped_lock(scoped_lock const&) = delete;
Show All 30 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// <mutex> // <mutex>
// template <class ...Mutex> class scoped_lock; // template <class ...Mutex> class scoped_lock;
// explicit scoped_lock(Mutex&...); // explicit scoped_lock(Mutex&...);
Show All 37 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// <mutex> // <mutex>
// template <class ...Mutex> class scoped_lock; // template <class ...Mutex> class scoped_lock;
// explicit scoped_lock(mutex_type& m); // explicit scoped_lock(mutex_type& m);
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// <mutex> // <mutex>
// template <class... MutexTypes> // template <class... MutexTypes>
// class scoped_lock // class scoped_lock
// { // {
// public: // public:
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
Show All 16 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
Show All 39 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
Show All 34 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
Show All 31 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
Show All 29 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// class timed_mutex; // class timed_mutex;
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// //
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// template <class Rep, class Period> // template <class Rep, class Period>
// bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); // bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); // bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// void unlock(); // void unlock();
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// void swap(shared_lock& u) noexcept; // void swap(shared_lock& u) noexcept;
Show All 26 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// template <class Mutex> // template <class Mutex>
// void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept; // void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
Show All 27 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// mutex_type* release() noexcept; // mutex_type* release() noexcept;
Show All 34 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
Show All 22 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// explicit operator bool() const noexcept; // explicit operator bool() const noexcept;
Show All 27 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// dylib support for shared_mutex was added in macosx10.12 // dylib support for shared_mutex was added in macosx10.12
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
Show All 22 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> // template <class Mutex>
// class shared_lock // class shared_lock
// { // {
Show All 18 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock(); // unique_lock();
#include <mutex> #include <mutex>
Show All 12 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.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: libcpp-has-no-threads, c++03 // UNSUPPORTED: no-threads, c++03
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock& operator=(unique_lock&& u); // unique_lock& operator=(unique_lock&& u);
#include <mutex> #include <mutex>
Show All 34 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.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: libcpp-has-no-threads, c++03 // UNSUPPORTED: no-threads, c++03
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock(unique_lock&& u); // unique_lock(unique_lock&& u);
#include <mutex> #include <mutex>
Show All 30 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// explicit unique_lock(mutex_type& m); // explicit unique_lock(mutex_type& m);
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock(mutex_type& m, adopt_lock_t); // unique_lock(mutex_type& m, adopt_lock_t);
#include <mutex> #include <mutex>
Show All 26 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock(mutex_type& m, defer_lock_t); // unique_lock(mutex_type& m, defer_lock_t);
#include <mutex> #include <mutex>
Show All 24 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// template <class Rep, class Period> // template <class Rep, class Period>
// unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time); // unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time); // unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// unique_lock(mutex_type& m, try_to_lock_t); // unique_lock(mutex_type& m, try_to_lock_t);
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// void lock(); // void lock();
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// //
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// bool try_lock(); // bool try_lock();
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// template <class Rep, class Period> // template <class Rep, class Period>
// bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); // bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); // bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// void unlock(); // void unlock();
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// void swap(unique_lock& u); // void swap(unique_lock& u);
#include <mutex> #include <mutex>
Show All 24 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// template <class Mutex> // template <class Mutex>
// void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y); // void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y);
Show All 25 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// mutex_type* release() noexcept; // mutex_type* release() noexcept;
#include <mutex> #include <mutex>
Show All 32 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// mutex_type *mutex() const; // mutex_type *mutex() const;
#include <mutex> #include <mutex>
Show All 17 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// explicit operator bool() const noexcept; // explicit operator bool() const noexcept;
#include <mutex> #include <mutex>
Show All 22 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// bool owns_lock() const; // bool owns_lock() const;
#include <mutex> #include <mutex>
Show All 17 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// template <class Mutex> // template <class Mutex>
// class unique_lock // class unique_lock
// { // {
// public: // public:
// typedef Mutex mutex_type; // typedef Mutex mutex_type;
Show All 15 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/types.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// struct defer_lock_t { explicit defer_lock_t() = default; }; // struct defer_lock_t { explicit defer_lock_t() = default; };
// struct try_to_lock_t { explicit try_to_lock_t() = default; }; // struct try_to_lock_t { explicit try_to_lock_t() = default; };
// struct adopt_lock_t { explicit adopt_lock_t() = default; }; // struct adopt_lock_t { explicit adopt_lock_t() = default; };
// This test checks for LWG 2510. // This test checks for LWG 2510.
Show All 11 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/types.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// struct defer_lock_t { explicit defer_lock_t() = default; }; // struct defer_lock_t { explicit defer_lock_t() = default; };
// struct try_to_lock_t { explicit try_to_lock_t() = default; }; // struct try_to_lock_t { explicit try_to_lock_t() = default; };
// struct adopt_lock_t { explicit adopt_lock_t() = default; }; // struct adopt_lock_t { explicit adopt_lock_t() = default; };
// //
// constexpr defer_lock_t defer_lock{}; // constexpr defer_lock_t defer_lock{};
Show All 19 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// class mutex; // class mutex;
// mutex(); // mutex();
#include <mutex> #include <mutex>
Show All 11 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class mutex; // class mutex;
// void lock(); // void lock();
Show All 36 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class mutex; // class mutex;
// bool try_lock(); // bool try_lock();
Show All 40 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// class recursive_mutex; // class recursive_mutex;
// recursive_mutex(); // recursive_mutex();
#include <mutex> #include <mutex>
Show All 9 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class recursive_mutex; // class recursive_mutex;
// void lock(); // void lock();
Show All 38 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class recursive_mutex; // class recursive_mutex;
// bool try_lock(); // bool try_lock();
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// shared_mutex was introduced in macosx10.12 // shared_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// class shared_mutex; // class shared_mutex;
Show All 13 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// shared_mutex was introduced in macosx10.12 // shared_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// class shared_mutex; // class shared_mutex;
Show All 12 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// shared_mutex was introduced in macosx10.12 // shared_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// class shared_mutex; // class shared_mutex;
Show All 13 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_mutex was introduced in macosx10.12 // shared_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_mutex was introduced in macosx10.12 // shared_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_mutex was introduced in macosx10.12 // shared_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_mutex was introduced in macosx10.12 // shared_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
Show All 13 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// ALLOW_RETRIES: 3 // ALLOW_RETRIES: 3
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// ALLOW_RETRIES: 3 // ALLOW_RETRIES: 3
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// shared_timed_mutex was introduced in macosx10.12 // shared_timed_mutex was introduced in macosx10.12
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// timed_mutex(); // timed_mutex();
#include <mutex> #include <mutex>
Show All 9 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// void lock(); // void lock();
Show All 36 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// bool try_lock(); // bool try_lock();
Show All 40 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// template <class Rep, class Period> // template <class Rep, class Period>
// bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); // bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); // bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// class recursive_timed_mutex; // class recursive_timed_mutex;
// recursive_timed_mutex(); // recursive_timed_mutex();
#include <mutex> #include <mutex>
Show All 9 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class recursive_timed_mutex; // class recursive_timed_mutex;
// void lock(); // void lock();
Show All 38 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class recursive_timed_mutex; // class recursive_timed_mutex;
// bool try_lock(); // bool try_lock();
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class recursive_timed_mutex; // class recursive_timed_mutex;
// template <class Rep, class Period> // template <class Rep, class Period>
// bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); // bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// <mutex> // <mutex>
// class recursive_timed_mutex; // class recursive_timed_mutex;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); // bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// struct once_flag; // struct once_flag;
// template<class Callable, class ...Args> // template<class Callable, class ...Args>
// void call_once(once_flag& flag, Callable&& func, Args&&... args); // void call_once(once_flag& flag, Callable&& func, Args&&... args);
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// struct once_flag; // struct once_flag;
// template<class Callable, class ...Args> // template<class Callable, class ...Args>
// void call_once(once_flag& flag, Callable&& func, Args&&... args); // void call_once(once_flag& flag, Callable&& func, Args&&... args);
Show All 35 Lines

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.compile.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// struct once_flag; // struct once_flag;
// once_flag& operator=(const once_flag&) = delete; // once_flag& operator=(const once_flag&) = delete;
#include <mutex> #include <mutex>
Show All 9 Lines

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.compile.fail.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// struct once_flag; // struct once_flag;
// once_flag(const once_flag&) = delete; // once_flag(const once_flag&) = delete;
#include <mutex> #include <mutex>
int main(int, char**) int main(int, char**)
{ {
std::once_flag f; std::once_flag f;
std::once_flag f2(f); std::once_flag f2(f);
return 0; return 0;
} }

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <mutex> // <mutex>
// struct once_flag; // struct once_flag;
// constexpr once_flag() noexcept; // constexpr once_flag() noexcept;
#include <mutex> #include <mutex>
Show All 17 Lines

libcxx/test/std/thread/thread.semaphore/acquire.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <semaphore> // <semaphore>
#include <semaphore> #include <semaphore>
Show All 18 Lines

libcxx/test/std/thread/thread.semaphore/binary.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <semaphore> // <semaphore>
#include <semaphore> #include <semaphore>
Show All 28 Lines

libcxx/test/std/thread/thread.semaphore/ctor.compile.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <semaphore> // <semaphore>
// constexpr explicit counting_semaphore(ptrdiff_t desired); // constexpr explicit counting_semaphore(ptrdiff_t desired);
#include <semaphore> #include <semaphore>
#include <type_traits> #include <type_traits>
Show All 14 Lines

libcxx/test/std/thread/thread.semaphore/max.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// <semaphore> // <semaphore>
#include <semaphore> #include <semaphore>
#include <thread> #include <thread>
#include "test_macros.h" #include "test_macros.h"
Show All 9 Lines

libcxx/test/std/thread/thread.semaphore/release.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <semaphore> // <semaphore>
#include <semaphore> #include <semaphore>
Show All 21 Lines

libcxx/test/std/thread/thread.semaphore/timed.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <semaphore> // <semaphore>
#include <semaphore> #include <semaphore>
Show All 32 Lines

libcxx/test/std/thread/thread.semaphore/try_acquire.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in macOS 11.0. // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
// <semaphore> // <semaphore>
#include <cassert> #include <cassert>
Show All 25 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// void swap(thread& x, thread& y); // void swap(thread& x, thread& y);
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// thread& operator=(thread&& t); // thread& operator=(thread&& t);
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// thread& operator=(thread&& t); // thread& operator=(thread&& t);
#include <thread> #include <thread>
Show All 31 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <thread> // <thread>
// class thread // class thread
// template <class F, class ...Args> thread(F&& f, Args&&... args); // template <class F, class ...Args> thread(F&& f, Args&&... args);
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: sanitizer-new-delete // UNSUPPORTED: sanitizer-new-delete
#include <thread> #include <thread>
#include <new> #include <new>
#include <atomic> #include <atomic>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include <vector> #include <vector>
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// thread(); // thread();
#include <thread> #include <thread>
Show All 11 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// thread(thread&& t); // thread(thread&& t);
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/robust_against_adl.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <thread> // <thread>
// class thread // class thread
// template <class F, class ...Args> thread(F&& f, Args&&... args); // template <class F, class ...Args> thread(F&& f, Args&&... args);
Show All 16 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// ~thread(); // ~thread();
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread::id // class thread::id
// id& operator=(const id&) = default; // id& operator=(const id&) = default;
#include <thread> #include <thread>
Show All 15 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread::id // class thread::id
// id(const id&) = default; // id(const id&) = default;
#include <thread> #include <thread>
Show All 12 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread::id // class thread::id
// id(); // id();
#include <thread> #include <thread>
Show All 11 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <thread> // <thread>
// Test that <thread> provides all of the arithmetic, enum, and pointer // Test that <thread> provides all of the arithmetic, enum, and pointer
// hash specializations. // hash specializations.
#include <thread> #include <thread>
Show All 13 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread::id // class thread::id
// bool operator==(thread::id x, thread::id y); // bool operator==(thread::id x, thread::id y);
// bool operator!=(thread::id x, thread::id y); // bool operator!=(thread::id x, thread::id y);
Show All 18 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread::id // class thread::id
// bool operator< (thread::id x, thread::id y); // bool operator< (thread::id x, thread::id y);
// bool operator<=(thread::id x, thread::id y); // bool operator<=(thread::id x, thread::id y);
// bool operator> (thread::id x, thread::id y); // bool operator> (thread::id x, thread::id y);
Show All 29 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <thread> // <thread>
// class thread::id // class thread::id
// template<class charT, class traits> // template<class charT, class traits>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& out, thread::id id); // operator<<(basic_ostream<charT, traits>& out, thread::id id);
Show All 15 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// template <class T> // template <class T>
// struct hash // struct hash
// : public unary_function<T, size_t> // : public unary_function<T, size_t>
// { // {
// size_t operator()(T val) const; // size_t operator()(T val) const;
Show All 22 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// void detach(); // void detach();
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// id get_id() const; // id get_id() const;
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// void join(); // void join();
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// bool joinable() const; // bool joinable() const;
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// void swap(thread& t); // void swap(thread& t);
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// class thread // class thread
// unsigned hardware_concurrency(); // unsigned hardware_concurrency();
#include <thread> #include <thread>
Show All 10 Lines

libcxx/test/std/thread/thread.threads/thread.thread.this/get_id.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// thread::id this_thread::get_id(); // thread::id this_thread::get_id();
#include <thread> #include <thread>
#include <cassert> #include <cassert>
Show All 9 Lines

libcxx/test/std/thread/thread.threads/thread.thread.this/sleep_until.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// template <class Clock, class Duration> // template <class Clock, class Duration>
// void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); // void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
#include <thread> #include <thread>
#include <cstdlib> #include <cstdlib>
Show All 18 Lines

libcxx/test/std/thread/thread.threads/thread.thread.this/yield.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <thread> // <thread>
// void this_thread::yield(); // void this_thread::yield();
#include <thread> #include <thread>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::this_thread::yield(); std::this_thread::yield();
return 0; return 0;
} }

libcxx/test/std/time/time.clock/time.clock.file/now.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// <chrono> // <chrono>
// file_clock // file_clock
Show All 19 Lines

libcxx/test/std/time/time.clock/time.clock.file/to_from_sys.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-filesystem-library // UNSUPPORTED: no-filesystem
// Filesystem is supported on Apple platforms starting with macosx10.15. // Filesystem is supported on Apple platforms starting with macosx10.15.
// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}} // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// <chrono> // <chrono>
// //
// file_clock // file_clock
// //
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/test/std/time/time.clock/time.clock.steady/consistency.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: libcpp-has-no-monotonic-clock // UNSUPPORTED: no-monotonic-clock
// Due to C++17 inline variables ASAN flags this test as containing an ODR // Due to C++17 inline variables ASAN flags this test as containing an ODR
// violation because Clock::is_steady is defined in both the dylib and this TU. // violation because Clock::is_steady is defined in both the dylib and this TU.
// UNSUPPORTED: asan // UNSUPPORTED: asan
// <chrono> // <chrono>
// steady_clock // steady_clock
Show All 22 Lines

libcxx/test/std/time/time.clock/time.clock.steady/now.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: libcpp-has-no-monotonic-clock // UNSUPPORTED: no-monotonic-clock
// <chrono> // <chrono>
// steady_clock // steady_clock
// static time_point now(); // static time_point now();
#include <chrono> #include <chrono>
Show All 15 Lines

libcxx/test/std/utilities/charconv/charconv.msvc/test.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, c++11, c++14 // UNSUPPORTED: c++03, c++11, c++14
// to_chars requires functions in the dylib that have not been introduced in older // to_chars requires functions in the dylib that have not been introduced in older
// versions of the dylib on macOS. // versions of the dylib on macOS.
// 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}}
// steady_clock requires threads. // steady_clock requires threads.
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: libcpp-has-no-random-device // UNSUPPORTED: no-random-device
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// XFAIL: LIBCXX-AIX-FIXME // XFAIL: LIBCXX-AIX-FIXME
// <charconv> // <charconv>
#include <type_traits> #include <type_traits>
// Work-around for sprintf_s's usage in the Microsoft tests. // Work-around for sprintf_s's usage in the Microsoft tests.
Show All 21 Lines

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.sh.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// UNSUPPORTED: libcpp-has-no-wide-characters // UNSUPPORTED: no-wide-characters
// Validate it works regardless of the signedness of `char`. // Validate it works regardless of the signedness of `char`.
// RUN: %{cxx} %{flags} %{compile_flags} -fsigned-char -fsyntax-only %s // RUN: %{cxx} %{flags} %{compile_flags} -fsigned-char -fsyntax-only %s
// RUN: %{cxx} %{flags} %{compile_flags} -funsigned-char -fsyntax-only %s // RUN: %{cxx} %{flags} %{compile_flags} -funsigned-char -fsyntax-only %s
// <format> // <format>
// [format.arg]/5.2 // [format.arg]/5.2
Show All 9 Lines

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_wformat_args.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// XFAIL: libcpp-has-no-wide-characters // XFAIL: no-wide-characters
// <format> // <format>
// template<class... Args> // template<class... Args>
// format-arg-store<wformat_context, Args...> // format-arg-store<wformat_context, Args...>
// make_wformat_args(const Args&... args); // make_wformat_args(const Args&... args);
#include <cassert> #include <cassert>
Show All 13 Lines

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/ctor.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// <format> // <format>
// The Standard does not specifiy a constructor // The Standard does not specifiy a constructor
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/locale.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// <format> // <format>
// std::locale locale(); // std::locale locale();
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.functions/format.locale.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO FMT Evaluate gcc-11 status // TODO FMT Evaluate gcc-11 status
// UNSUPPORTED: gcc-11 // UNSUPPORTED: gcc-11
// TODO FMT Investigate AppleClang ICE // TODO FMT Investigate AppleClang ICE
// UNSUPPORTED: apple-clang-13 // UNSUPPORTED: apple-clang-13
// <format> // <format>
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.functions/format_to.locale.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO FMT Evaluate gcc-11 status // TODO FMT Evaluate gcc-11 status
// UNSUPPORTED: gcc-11 // UNSUPPORTED: gcc-11
// TODO FMT Investigate AppleClang ICE // TODO FMT Investigate AppleClang ICE
// UNSUPPORTED: apple-clang-13 // UNSUPPORTED: apple-clang-13
// <format> // <format>
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.functions/format_to_n.locale.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO FMT Evaluate gcc-11 status // TODO FMT Evaluate gcc-11 status
// UNSUPPORTED: gcc-11 // UNSUPPORTED: gcc-11
// TODO FMT Investigate AppleClang ICE // TODO FMT Investigate AppleClang ICE
// UNSUPPORTED: apple-clang-13 // UNSUPPORTED: apple-clang-13
// <format> // <format>
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.functions/formatted_size.locale.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO FMT Evaluate gcc-11 status // TODO FMT Evaluate gcc-11 status
// UNSUPPORTED: gcc-11 // UNSUPPORTED: gcc-11
// TODO FMT Investigate AppleClang ICE // TODO FMT Investigate AppleClang ICE
// UNSUPPORTED: apple-clang-13 // UNSUPPORTED: apple-clang-13
// <format> // <format>
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.functions/locale-specific_form.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// The issue is caused in __format_spec::__determine_grouping(). // The issue is caused in __format_spec::__determine_grouping().
// There a string iterator is modified. The string is returned // There a string iterator is modified. The string is returned
// from the dylib's use_facet<numpunct<_CharT>>::grouping() // from the dylib's use_facet<numpunct<_CharT>>::grouping()
// XFAIL: LIBCXX-DEBUG-FIXME // XFAIL: LIBCXX-DEBUG-FIXME
// TODO FMT Evaluate gcc-11 status // TODO FMT Evaluate gcc-11 status
▲ Show 20 Lines • Show All 2,319 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.functions/vformat.locale.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO FMT Evaluate gcc-11 status // TODO FMT Evaluate gcc-11 status
// UNSUPPORTED: gcc-11 // UNSUPPORTED: gcc-11
// TODO FMT Investigate AppleClang ICE // TODO FMT Investigate AppleClang ICE
// UNSUPPORTED: apple-clang-13 // UNSUPPORTED: apple-clang-13
// <format> // <format>
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.functions/vformat_to.locale.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO FMT Evaluate gcc-11 status // TODO FMT Evaluate gcc-11 status
// UNSUPPORTED: gcc-11 // UNSUPPORTED: gcc-11
// TODO FMT Investigate AppleClang ICE // TODO FMT Investigate AppleClang ICE
// UNSUPPORTED: apple-clang-13 // UNSUPPORTED: apple-clang-13
// <format> // <format>
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

libcxx/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Because we don't have a functioning decltype in C++03 // Because we don't have a functioning decltype in C++03
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <memory> // <memory>
// unique_ptr // unique_ptr
// template<class CharT, class Traits, class Y, class D> // template<class CharT, class Traits, class Y, class D>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
// operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p); // operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p);
Show All 18 Lines

libcxx/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.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
// Because we don't have a functioning decltype in C++03 // Because we don't have a functioning decltype in C++03
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <memory> // <memory>
// unique_ptr // unique_ptr
// template<class CharT, class Traits, class Y, class D> // template<class CharT, class Traits, class Y, class D>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
// operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p); // operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p);
Show All 17 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// bool // bool
// atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v, // atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v,
Show All 36 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// bool // bool
// atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v, // atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// bool // bool
// atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, // atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v,
Show All 34 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// bool // bool
// atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v, // atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// shared_ptr<T> // shared_ptr<T>
// atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r) // atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r)
Show All 20 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// shared_ptr<T> // shared_ptr<T>
// atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r) // atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r)
Show All 22 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template<class T> // template<class T>
// bool // bool
// atomic_is_lock_free(const shared_ptr<T>* p); // atomic_is_lock_free(const shared_ptr<T>* p);
Show All 17 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// shared_ptr<T> // shared_ptr<T>
// atomic_load(const shared_ptr<T>* p) // atomic_load(const shared_ptr<T>* p)
Show All 18 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// shared_ptr<T> // shared_ptr<T>
// atomic_load_explicit(const shared_ptr<T>* p, memory_order mo) // atomic_load_explicit(const shared_ptr<T>* p, memory_order mo)
Show All 20 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// void // void
// atomic_store(shared_ptr<T>* p, shared_ptr<T> r) // atomic_store(shared_ptr<T>* p, shared_ptr<T> r)
Show All 19 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// <memory> // <memory>
// shared_ptr // shared_ptr
// template <class T> // template <class T>
// void // void
// atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo) // atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo)
Show All 21 Lines

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// <memory> // <memory>
// shared_ptr // shared_ptr
// template<class CharT, class Traits, class Y> // template<class CharT, class Traits, class Y>
// basic_ostream<CharT, Traits>& // basic_ostream<CharT, Traits>&
// operator<<(basic_ostream<CharT, Traits>& os, shared_ptr<Y> const& p); // operator<<(basic_ostream<CharT, Traits>& os, shared_ptr<Y> const& p);
Show All 17 Lines

libcxx/test/std/utilities/template.bitset/bitset.operators/stream_in.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// test: // test:
// template <class charT, class traits, size_t N> // template <class charT, class traits, size_t N>
// basic_istream<charT, traits>& // basic_istream<charT, traits>&
// operator>>(basic_istream<charT, traits>& is, bitset<N>& x); // operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
#include <bitset> #include <bitset>
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/utilities/template.bitset/bitset.operators/stream_out.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: libcpp-has-no-localization // UNSUPPORTED: no-localization
// test: // test:
// template <class charT, class traits, size_t N> // template <class charT, class traits, size_t N>
// basic_ostream<charT, traits>& // basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x); // operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
#include <bitset> #include <bitset>
Show All 14 Lines

libcxx/test/support/test.support/make_string_header.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
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: no-localization
// "support/make_string.h" // "support/make_string.h"
#include "make_string.h" #include "make_string.h"
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
Show All 39 Lines

libcxx/utils/generate_feature_test_macro_components.py

Show First 20 Lines • Show All 758 Lines • ▼ Show 20 Lines
# Map from each header to the Lit annotations that should be used for # Map from each header to the Lit annotations that should be used for
# tests that include that header. # tests that include that header.
# #
# For example, when threads are not supported, any test that includes # For example, when threads are not supported, any test that includes
# <thread> should be marked as UNSUPPORTED, because including <thread> # <thread> should be marked as UNSUPPORTED, because including <thread>
# is a hard error in that case. # is a hard error in that case.
lit_markup = { lit_markup = {
"barrier": ["UNSUPPORTED: libcpp-has-no-threads"], "barrier": ["UNSUPPORTED: no-threads"],
"filesystem": ["UNSUPPORTED: libcpp-has-no-filesystem-library"], "filesystem": ["UNSUPPORTED: no-filesystem"],
"format": ["UNSUPPORTED: libcpp-has-no-incomplete-format"], "format": ["UNSUPPORTED: libcpp-has-no-incomplete-format"],
"iomanip": ["UNSUPPORTED: libcpp-has-no-localization"], "iomanip": ["UNSUPPORTED: no-localization"],
"ios": ["UNSUPPORTED: libcpp-has-no-localization"], "ios": ["UNSUPPORTED: no-localization"],
"iostream": ["UNSUPPORTED: libcpp-has-no-localization"], "iostream": ["UNSUPPORTED: no-localization"],
"istream": ["UNSUPPORTED: libcpp-has-no-localization"], "istream": ["UNSUPPORTED: no-localization"],
"latch": ["UNSUPPORTED: libcpp-has-no-threads"], "latch": ["UNSUPPORTED: no-threads"],
"locale": ["UNSUPPORTED: libcpp-has-no-localization"], "locale": ["UNSUPPORTED: no-localization"],
"mutex": ["UNSUPPORTED: libcpp-has-no-threads"], "mutex": ["UNSUPPORTED: no-threads"],
"ostream": ["UNSUPPORTED: libcpp-has-no-localization"], "ostream": ["UNSUPPORTED: no-localization"],
"ranges": ["UNSUPPORTED: libcpp-has-no-incomplete-ranges"], "ranges": ["UNSUPPORTED: libcpp-has-no-incomplete-ranges"],
"regex": ["UNSUPPORTED: libcpp-has-no-localization"], "regex": ["UNSUPPORTED: no-localization"],
"semaphore": ["UNSUPPORTED: libcpp-has-no-threads"], "semaphore": ["UNSUPPORTED: no-threads"],
"shared_mutex": ["UNSUPPORTED: libcpp-has-no-threads"], "shared_mutex": ["UNSUPPORTED: no-threads"],
"stdatomic.h": ["UNSUPPORTED: libcpp-has-no-threads"], "stdatomic.h": ["UNSUPPORTED: no-threads"],
"thread": ["UNSUPPORTED: libcpp-has-no-threads"], "thread": ["UNSUPPORTED: no-threads"],
} }
def get_std_dialects(): def get_std_dialects():
std_dialects = ['c++14', 'c++17', 'c++20', 'c++2b'] std_dialects = ['c++14', 'c++17', 'c++20', 'c++2b']
return list(std_dialects) return list(std_dialects)
def get_first_std(d): def get_first_std(d):
for s in get_std_dialects(): for s in get_std_dialects():
▲ Show 20 Lines • Show All 420 Lines • Show Last 20 Lines

libcxx/utils/generate_header_inclusion_tests.py

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines
# Map from each header to the Lit annotations that should be used for # Map from each header to the Lit annotations that should be used for
# tests that include that header. # tests that include that header.
# #
# For example, when threads are not supported, any test that includes # For example, when threads are not supported, any test that includes
# <thread> should be marked as UNSUPPORTED, because including <thread> # <thread> should be marked as UNSUPPORTED, because including <thread>
# is a hard error in that case. # is a hard error in that case.
lit_markup = { lit_markup = {
"barrier": ["UNSUPPORTED: libcpp-has-no-threads"], "barrier": ["UNSUPPORTED: no-threads"],
"filesystem": ["UNSUPPORTED: libcpp-has-no-filesystem-library"], "filesystem": ["UNSUPPORTED: no-filesystem"],
"format": ["UNSUPPORTED: libcpp-has-no-incomplete-format"], "format": ["UNSUPPORTED: libcpp-has-no-incomplete-format"],
"iomanip": ["UNSUPPORTED: libcpp-has-no-localization"], "iomanip": ["UNSUPPORTED: no-localization"],
"ios": ["UNSUPPORTED: libcpp-has-no-localization"], "ios": ["UNSUPPORTED: no-localization"],
"iostream": ["UNSUPPORTED: libcpp-has-no-localization"], "iostream": ["UNSUPPORTED: no-localization"],
"istream": ["UNSUPPORTED: libcpp-has-no-localization"], "istream": ["UNSUPPORTED: no-localization"],
"latch": ["UNSUPPORTED: libcpp-has-no-threads"], "latch": ["UNSUPPORTED: no-threads"],
"locale": ["UNSUPPORTED: libcpp-has-no-localization"], "locale": ["UNSUPPORTED: no-localization"],
"mutex": ["UNSUPPORTED: libcpp-has-no-threads"], "mutex": ["UNSUPPORTED: no-threads"],
"ostream": ["UNSUPPORTED: libcpp-has-no-localization"], "ostream": ["UNSUPPORTED: no-localization"],
"ranges": ["UNSUPPORTED: libcpp-has-no-incomplete-ranges"], "ranges": ["UNSUPPORTED: libcpp-has-no-incomplete-ranges"],
"regex": ["UNSUPPORTED: libcpp-has-no-localization"], "regex": ["UNSUPPORTED: no-localization"],
"semaphore": ["UNSUPPORTED: libcpp-has-no-threads"], "semaphore": ["UNSUPPORTED: no-threads"],
"shared_mutex": ["UNSUPPORTED: libcpp-has-no-threads"], "shared_mutex": ["UNSUPPORTED: no-threads"],
"thread": ["UNSUPPORTED: libcpp-has-no-threads"] "thread": ["UNSUPPORTED: no-threads"]
} }
def get_std_ver_test(includee): def get_std_ver_test(includee):
v = new_in_version.get(includee, "03") v = new_in_version.get(includee, "03")
if v == "03": if v == "03":
return '' return ''
versions = ["03", "11", "14", "17", "20"] versions = ["03", "11", "14", "17", "20"]
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

libcxx/utils/libcxx/test/features.py

Show First 20 Lines • Show All 168 Lines • ▼ Show 20 Lines
# Deduce and add the test features that that are implied by the #defines in # Deduce and add the test features that that are implied by the #defines in
# the <__config_site> header. # the <__config_site> header.
# #
# For each macro of the form `_LIBCPP_XXX_YYY_ZZZ` defined below that # For each macro of the form `_LIBCPP_XXX_YYY_ZZZ` defined below that
# is defined after including <__config_site>, add a Lit feature called # is defined after including <__config_site>, add a Lit feature called
# `libcpp-xxx-yyy-zzz`. When a macro is defined to a specific value # `libcpp-xxx-yyy-zzz`. When a macro is defined to a specific value
# (e.g. `_LIBCPP_ABI_VERSION=2`), the feature is `libcpp-xxx-yyy-zzz=<value>`. # (e.g. `_LIBCPP_ABI_VERSION=2`), the feature is `libcpp-xxx-yyy-zzz=<value>`.
#
# Note that features that are more strongly tied to libc++ are named libcpp-foo,
# while features that are more general in nature are not prefixed with 'libcpp-'.
macros = { macros = {
'_LIBCPP_HAS_NO_MONOTONIC_CLOCK': 'libcpp-has-no-monotonic-clock', '_LIBCPP_HAS_NO_MONOTONIC_CLOCK': 'no-monotonic-clock',
'_LIBCPP_HAS_NO_THREADS': 'libcpp-has-no-threads', '_LIBCPP_HAS_NO_THREADS': 'no-threads',
'_LIBCPP_HAS_THREAD_API_EXTERNAL': 'libcpp-has-thread-api-external', '_LIBCPP_HAS_THREAD_API_EXTERNAL': 'libcpp-has-thread-api-external',
'_LIBCPP_HAS_THREAD_API_PTHREAD': 'libcpp-has-thread-api-pthread', '_LIBCPP_HAS_THREAD_API_PTHREAD': 'libcpp-has-thread-api-pthread',
'_LIBCPP_NO_VCRUNTIME': 'libcpp-no-vcruntime', '_LIBCPP_NO_VCRUNTIME': 'libcpp-no-vcruntime',
'_LIBCPP_ABI_VERSION': 'libcpp-abi-version', '_LIBCPP_ABI_VERSION': 'libcpp-abi-version',
'_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY': 'libcpp-has-no-filesystem-library', '_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY': 'no-filesystem',
'_LIBCPP_HAS_NO_RANDOM_DEVICE': 'libcpp-has-no-random-device', '_LIBCPP_HAS_NO_RANDOM_DEVICE': 'no-random-device',
'_LIBCPP_HAS_NO_LOCALIZATION': 'libcpp-has-no-localization', '_LIBCPP_HAS_NO_LOCALIZATION': 'no-localization',
'_LIBCPP_HAS_NO_WIDE_CHARACTERS': 'libcpp-has-no-wide-characters', '_LIBCPP_HAS_NO_WIDE_CHARACTERS': 'no-wide-characters',
'_LIBCPP_HAS_NO_INCOMPLETE_FORMAT': 'libcpp-has-no-incomplete-format', '_LIBCPP_HAS_NO_INCOMPLETE_FORMAT': 'libcpp-has-no-incomplete-format',
'_LIBCPP_HAS_NO_INCOMPLETE_RANGES': 'libcpp-has-no-incomplete-ranges', '_LIBCPP_HAS_NO_INCOMPLETE_RANGES': 'libcpp-has-no-incomplete-ranges',
'_LIBCPP_HAS_NO_UNICODE': 'libcpp-has-no-unicode', '_LIBCPP_HAS_NO_UNICODE': 'libcpp-has-no-unicode',
} }
for macro, feature in macros.items(): for macro, feature in macros.items():
DEFAULT_FEATURES.append( DEFAULT_FEATURES.append(
Feature(name=lambda cfg, m=macro, f=feature: f + ('={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''), Feature(name=lambda cfg, m=macro, f=feature: f + ('={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''),
when=lambda cfg, m=macro: m in compilerMacros(cfg)) when=lambda cfg, m=macro: m in compilerMacros(cfg))
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/utils/libcxx/test/target_info.py

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines def __init__(self, full_config):
super(LinuxLocalTI, self).__init__(full_config) super(LinuxLocalTI, self).__init__(full_config)
def add_cxx_compile_flags(self, flags): def add_cxx_compile_flags(self, flags):
flags += ['-D__STDC_FORMAT_MACROS', flags += ['-D__STDC_FORMAT_MACROS',
'-D__STDC_LIMIT_MACROS', '-D__STDC_LIMIT_MACROS',
'-D__STDC_CONSTANT_MACROS'] '-D__STDC_CONSTANT_MACROS']
def add_cxx_link_flags(self, flags): def add_cxx_link_flags(self, flags):
enable_threads = ('libcpp-has-no-threads' not in enable_threads = ('no-threads' not in
self.full_config.config.available_features) self.full_config.config.available_features)
llvm_unwinder = self.full_config.get_lit_bool('llvm_unwinder', False) llvm_unwinder = self.full_config.get_lit_bool('llvm_unwinder', False)
shared_libcxx = self.full_config.get_lit_bool('enable_shared', True) shared_libcxx = self.full_config.get_lit_bool('enable_shared', True)
flags += ['-lm'] flags += ['-lm']
if not llvm_unwinder: if not llvm_unwinder:
flags += ['-lgcc_s', '-lgcc'] flags += ['-lgcc_s', '-lgcc']
if enable_threads: if enable_threads:
flags += ['-lpthread'] flags += ['-lpthread']
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libcxxabi/test/cxa_thread_atexit_test.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: libcpp-has-no-threads // UNSUPPORTED: no-threads
// REQUIRES: linux // REQUIRES: linux
#include <assert.h> #include <assert.h>
#include <cxxabi.h> #include <cxxabi.h>
static bool AtexitImplCalled = false; static bool AtexitImplCalled = false;
extern "C" int __cxa_thread_atexit_impl(void (*dtor)(void *), void *obj, extern "C" int __cxa_thread_atexit_impl(void (*dtor)(void *), void *obj,
Show All 16 Lines

libcxxabi/test/forced_unwind3.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Let's run ForcedUnwind until it reaches end of the stack, this test simulates // Let's run ForcedUnwind until it reaches end of the stack, this test simulates
// what pthread_cancel does. // what pthread_cancel does.
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: no-exceptions // UNSUPPORTED: no-exceptions
#include <assert.h> #include <assert.h>
#include <exception> #include <exception>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unwind.h> #include <unwind.h>
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libcxxabi/test/guard_threaded_test.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
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
// UNSUPPORTED: no-exceptions // UNSUPPORTED: no-exceptions
#define TESTING_CXA_GUARD #define TESTING_CXA_GUARD
#include "../src/cxa_guard_impl.h" #include "../src/cxa_guard_impl.h"
#include <unordered_map> #include <unordered_map>
#include <thread> #include <thread>
#include <atomic> #include <atomic>
#include <array> #include <array>
▲ Show 20 Lines • Show All 368 Lines • Show Last 20 Lines

libcxxabi/test/libcxxabi/test/config.py

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesclass Configuration(LibcxxConfiguration):
def configure_compile_flags(self): def configure_compile_flags(self):
self.cxx.compile_flags += [ self.cxx.compile_flags += [
'-D_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS', '-D_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS',
] ]
if self.get_lit_bool('enable_exceptions', True): if self.get_lit_bool('enable_exceptions', True):
self.cxx.compile_flags += ['-funwind-tables'] self.cxx.compile_flags += ['-funwind-tables']
if not self.get_lit_bool('enable_threads', True): if not self.get_lit_bool('enable_threads', True):
self.cxx.compile_flags += ['-D_LIBCXXABI_HAS_NO_THREADS'] self.cxx.compile_flags += ['-D_LIBCXXABI_HAS_NO_THREADS']
self.config.available_features.add('libcpp-has-no-threads') self.config.available_features.add('no-threads')
super(Configuration, self).configure_compile_flags() super(Configuration, self).configure_compile_flags()
def configure_compile_flags_header_includes(self): def configure_compile_flags_header_includes(self):
cxx_headers = self.get_lit_conf('cxx_headers', None) or \ cxx_headers = self.get_lit_conf('cxx_headers', None) or \
os.path.join(self.libcxxabi_hdr_root, 'include', 'c++', 'v1') os.path.join(self.libcxxabi_hdr_root, 'include', 'c++', 'v1')
if cxx_headers == '': if cxx_headers == '':
self.lit_config.note('using the systems c++ headers') self.lit_config.note('using the systems c++ headers')
else: else:
Show All 28 Lines

libcxxabi/test/test_fallback_malloc.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <cstdio> #include <cstdio>
#include <deque> #include <deque>
#include <__threading_support> #include <__threading_support>
// UNSUPPORTED: modules-build && libcpp-has-no-threads // UNSUPPORTED: modules-build && no-threads
// Necessary because we include a private source file of libc++abi, which // Necessary because we include a private source file of libc++abi, which
// only understands _LIBCXXABI_HAS_NO_THREADS. // only understands _LIBCXXABI_HAS_NO_THREADS.
#include "test_macros.h" #include "test_macros.h"
#ifdef TEST_HAS_NO_THREADS #ifdef TEST_HAS_NO_THREADS
# define _LIBCXXABI_HAS_NO_THREADS # define _LIBCXXABI_HAS_NO_THREADS
#endif #endif
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

libcxxabi/test/thread_local_destruction_order.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
// UNSUPPORTED: libcpp-has-no-threads // UNSUPPORTED: no-threads
#include <cassert> #include <cassert>
#include <thread> #include <thread>
#include "make_test_thread.h" #include "make_test_thread.h"
int seq = 0; int seq = 0;
Show All 40 Lines