This is an archive of the discontinued LLVM Phabricator instance.

Differential D112737

[libc++] Temporarily mark tests as UNSUPPORTED to get the CI green
ClosedPublic

Authored by ldionne on Oct 28 2021, 10:58 AM.

Details

Reviewers
Mordante
ldionne
Group Reviewers
Restricted Project
Restricted Project
Restricted Project
Commits
rGa55632a069d8: [libc++] Temporarily mark tests as UNSUPPORTED to get the CI green
Summary

After recent changes to the Docker image, all hell broke loose and the
CI started failing. This patch marks a few tests as unsupported until
we can figure out what the issues are and fix them.

In the future, it would be ideal if the nodes could pick up the Dockerfile
present in the revision being tested, which would allow us to test changes
to the Dockerfile in the CI, like we do for all other code changes.

Diff Detail

Event Timeline

ldionne requested review of this revision.Oct 28 2021, 10:58 AM
ldionne created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptOct 28 2021, 10:58 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
jloser added a subscriber: jloser.Oct 28 2021, 11:04 AM
jloser added inline comments.
libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
17

Can we just XFAIL them for gcc11 instead for now? Ditto for the other uses.

Mordante accepted this revision as: Mordante.Oct 28 2021, 11:06 AM

Thanks for addressing these issues! LGTM!

ldionne updated this revision to Diff 383089.Oct 28 2021, 11:06 AM

Correct invalid UNSUPPORTED markup.

ldionne marked an inline comment as done.Oct 28 2021, 11:11 AM
ldionne added inline comments.
libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
17

No, these tests fail in various circumstances like ASAN on Clang 14, Debug iterators and other jobs. Since this is ultra temporary, I'm fine with using a coarse grained UNSUPPORTED.

jloser added inline comments.Oct 28 2021, 11:14 AM
libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
17

Got it, thanks for the explanation.

Mordante added inline comments.Oct 28 2021, 11:15 AM
libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
17

Normally I agree with this sentiment. But my change accidentally broke the entire CI. So I prefer this work-around and then fix it properly afterwards. That way we can keep using our CI while we sort the fallout later.

It seems updating the Dockerfile in a commit doesn't cause the CI to use these changes.

Harbormaster completed remote builds in B131241: Diff 383089.Oct 28 2021, 11:23 AM
ldionne updated this revision to Diff 383102.Oct 28 2021, 11:27 AM
ldionne marked an inline comment as done.

Remove XFAIL for libunwind test on GCC. Frankly I don't know why it passes suddenly.

Herald added a project: Restricted Project. · View Herald TranscriptOct 28 2021, 11:27 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Harbormaster completed remote builds in B131249: Diff 383102.Oct 28 2021, 12:20 PM
ldionne updated this revision to Diff 383124.Oct 28 2021, 12:38 PM

Add a ton of UNSUPPORTED on the 32 bits job. For some reason they fail with something I can't even reproduce locally in the same Docker image.

ldionne updated this revision to Diff 383141.Oct 28 2021, 1:17 PM

Fix libc++abi issue on 32 bits. Should be all good if libunwind passes.

I've said it before, but I can't reproduce any of these 32-bit issues on a Docker image locally, which is quite weird.

Herald added a project: Restricted Project. · View Herald TranscriptOct 28 2021, 1:17 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: arichardson. · View Herald Transcript
Harbormaster completed remote builds in B131277: Diff 383141.Oct 28 2021, 1:30 PM
ldionne updated this revision to Diff 383145.Oct 28 2021, 1:30 PM

Everything should pass now, shipping.

ldionne accepted this revision.Oct 28 2021, 1:30 PM
This revision is now accepted and ready to land.Oct 28 2021, 1:30 PM
This revision was landed with ongoing or failed builds.Oct 28 2021, 1:30 PM
Closed by commit rGa55632a069d8: [libc++] Temporarily mark tests as UNSUPPORTED to get the CI green (authored by ldionne). · Explain Why
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rGa55632a069d8: [libc++] Temporarily mark tests as UNSUPPORTED to get the CI green.
Harbormaster completed remote builds in B131282: Diff 383145.Oct 28 2021, 2:20 PM
Mordante mentioned this in D113133: [libc++] Improve no wide characters configuration..Nov 3 2021, 11:36 AM
Mordante mentioned this in D113137: [libc++] Fix lifetime issues of temporaries..Nov 3 2021, 12:53 PM
Mordante mentioned this in D113139: [libc++] Mark a failing test..Nov 3 2021, 1:12 PM
Mordante mentioned this in rG5de4864f74bd: [libc++] Improve no wide characters configuration..Nov 4 2021, 11:35 AM
Mordante mentioned this in rGa948a0a23ce7: [libc++] Mark a failing test..Nov 9 2021, 10:00 AM
Mordante mentioned this in rG1e78d5d008f9: [libc++] Fix lifetime issues of temporaries..

Revision Contents

PathSize
libcxx/
test/
libcxx/
input.output/
filesystems/
class.directory_entry/
directory_entry.mods/
3 lines
thread/
thread.condition/
3 lines
thread.threads/
thread.thread.this/
3 lines
3 lines
std/
input.output/
filesystems/
fs.op.funcs/
fs.op.copy_file/
3 lines
fs.op.last_write_time/
3 lines
localization/
locale.categories/
category.monetary/
locale.money.get/
locale.money.get.members/
7 lines
locale.money.put/
locale.money.put.members/
7 lines
locale.moneypunct.byname/
5 lines
facet.numpunct/
locale.numpunct.byname/
5 lines
thread/
futures/
futures.async/
3 lines
futures.shared_future/
3 lines
3 lines
3 lines
futures.unique_future/
3 lines
3 lines
3 lines
thread.barrier/
3 lines
3 lines
3 lines
3 lines
thread.condition/
3 lines
thread.condition.condvar/
3 lines
3 lines
3 lines
3 lines
3 lines
thread.condition.condvarany/
4 lines
3 lines
3 lines
3 lines
3 lines
thread.latch/
3 lines
3 lines
thread.mutex/
thread.lock/
thread.lock.shared/
thread.lock.shared.cons/
4 lines
3 lines
3 lines
4 lines
thread.lock.shared.locking/
4 lines
3 lines
thread.lock.unique/
thread.lock.unique.cons/
4 lines
4 lines
4 lines
3 lines
thread.lock.unique.locking/
4 lines
3 lines
thread.mutex.requirements/
thread.mutex.requirements.mutex/
thread.mutex.class/
4 lines
4 lines
thread.mutex.recursive/
3 lines
4 lines
thread.shared_mutex.requirements/
thread.shared_mutex.class/
3 lines
3 lines
3 lines
3 lines
thread.sharedtimedmutex.requirements/
thread.sharedtimedmutex.class/
3 lines
3 lines
3 lines
4 lines
3 lines
3 lines
3 lines
3 lines
3 lines
thread.timedmutex.requirements/
thread.timedmutex.class/
3 lines
3 lines
3 lines
3 lines
thread.timedmutex.recursive/
3 lines
3 lines
3 lines
3 lines
thread.semaphore/
3 lines
3 lines
3 lines
thread.threads/
thread.thread.this/
3 lines
utilities/
format/
format.formatter/
format.context/
format.context/
3 lines
3 lines
format.functions/
3 lines
time/
time.clock/
time.clock.hires/
3 lines
time.clock.file/
3 lines
time.clock.steady/
3 lines
time.clock.system/
3 lines
3 lines
3 lines
libcxxabi/
test/
3 lines
libunwind/
test/
3 lines

Diff 383146

libcxx/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.pass.cpp

Show All 9 Lines
// ADDITIONAL_COMPILE_FLAGS: -I %S/../../../../../../src/filesystem // ADDITIONAL_COMPILE_FLAGS: -I %S/../../../../../../src/filesystem
// This test relies on calling functions from the libcxx internal header // This test relies on calling functions from the libcxx internal header
// filesystem_common.h; the Windows implementation uses different // filesystem_common.h; the Windows implementation uses different
// internals and doesn't provide the same set_file_times function as for // internals and doesn't provide the same set_file_times function as for
// other platforms. // other platforms.
// UNSUPPORTED: windows // UNSUPPORTED: windows
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <filesystem> // <filesystem>
// class directory_entry // class directory_entry
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp

Show All 10 Lines
// 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <condition_variable> // <condition_variable>
// void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); // void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
// Test that this function works with threads that were not created by // Test that this function works with threads that were not created by
// std::thread. See https://llvm.org/PR30202 // std::thread. See https://llvm.org/PR30202
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <thread> // <thread>
// template <class Rep, class Period> // template <class Rep, class Period>
// void sleep_for(const chrono::duration<Rep, Period>& rel_time); // void sleep_for(const chrono::duration<Rep, Period>& rel_time);
#include <thread> #include <thread>
#include <cassert> #include <cassert>
#include <chrono> #include <chrono>
Show All 15 Lines

libcxx/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.signals.pass.cpp

Show All 10 Lines
// 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <thread> // <thread>
// template <class Rep, class Period> // template <class Rep, class Period>
// void sleep_for(const chrono::duration<Rep, Period>& rel_time); // void sleep_for(const chrono::duration<Rep, Period>& rel_time);
// This test ensures that we sleep for the right amount of time even when // This test ensures that we sleep for the right amount of time even when
// we get interrupted by a signal, as fixed in 58a0a70fb2f1. // we get interrupted by a signal, as fixed in 58a0a70fb2f1.
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/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
// The string reported on errors changed, which makes those tests fail when run // The string reported on errors changed, which makes those tests fail when run
// against already-released libc++'s. // against already-released libc++'s.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.15 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.15
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <filesystem> // <filesystem>
// bool copy_file(const path& from, const path& to); // bool copy_file(const path& from, const path& to);
// bool copy_file(const path& from, const path& to, error_code& ec) noexcept; // bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
// bool copy_file(const path& from, const path& to, copy_options options); // bool copy_file(const path& from, const path& to, copy_options options);
// bool copy_file(const path& from, const path& to, copy_options options, // bool copy_file(const path& from, const path& to, copy_options options,
// error_code& ec) noexcept; // error_code& ec) noexcept;
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/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
// The string reported on errors changed, which makes those tests fail when run // The string reported on errors changed, which makes those tests fail when run
// against already-released libc++'s. // against already-released libc++'s.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.15 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.15
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <filesystem> // <filesystem>
// file_time_type last_write_time(const path& p); // file_time_type last_write_time(const path& p);
// file_time_type last_write_time(const path& p, std::error_code& ec) noexcept; // file_time_type last_write_time(const path& p, std::error_code& ec) noexcept;
// void last_write_time(const path& p, file_time_type new_time); // void last_write_time(const path& p, file_time_type new_time);
// void last_write_time(const path& p, file_time_type new_type, // void last_write_time(const path& p, file_time_type new_type,
// std::error_code& ec) noexcept; // std::error_code& ec) noexcept;
▲ Show 20 Lines • Show All 625 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.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: darwin // XFAIL: darwin
//
// NetBSD does not support LC_MONETARY at the moment // NetBSD does not support LC_MONETARY at the moment
// XFAIL: netbsd // XFAIL: netbsd
// XFAIL: LIBCXX-WINDOWS-FIXME // XFAIL: LIBCXX-WINDOWS-FIXME
// TODO(mordante): Investigate these localization/format failures since updating the Docker image in CI
// UNSUPPORTED: stdlib=libc++
jloserUnsubmitted
Done
ReplyInline Actions

Can we just XFAIL them for gcc11 instead for now? Ditto for the other uses.

jloser: Can we just `XFAIL` them for `gcc11` instead for now? Ditto for the other uses.
MordanteUnsubmitted
Not Done
ReplyInline Actions

Normally I agree with this sentiment. But my change accidentally broke the entire CI. So I prefer this work-around and then fix it properly afterwards. That way we can keep using our CI while we sort the fallout later.

It seems updating the Dockerfile in a commit doesn't cause the CI to use these changes.

Mordante: Normally I agree with this sentiment. But my change accidentally broke the entire CI. So I…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

No, these tests fail in various circumstances like ASAN on Clang 14, Debug iterators and other jobs. Since this is ultra temporary, I'm fine with using a coarse grained UNSUPPORTED.

ldionne: No, these tests fail in various circumstances like ASAN on Clang 14, Debug iterators and other…
jloserUnsubmitted
Done
ReplyInline Actions

Got it, thanks for the explanation.

jloser: Got it, thanks for the explanation.
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// <locale> // <locale>
// class money_get<charT, InputIterator> // class money_get<charT, InputIterator>
// iter_type get(iter_type b, iter_type e, bool intl, ios_base& iob, // iter_type get(iter_type b, iter_type e, bool intl, ios_base& iob,
// ios_base::iostate& err, long double& v) const; // ios_base::iostate& err, long double& v) const;
▲ Show 20 Lines • Show All 743 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.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: darwin // XFAIL: darwin
//
// NetBSD does not support LC_MONETARY at the moment // NetBSD does not support LC_MONETARY at the moment
// XFAIL: netbsd // XFAIL: netbsd
// XFAIL: LIBCXX-WINDOWS-FIXME // XFAIL: LIBCXX-WINDOWS-FIXME
// TODO(mordante): Investigate these localization/format failures since updating the Docker image in CI
// UNSUPPORTED: stdlib=libc++
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// <locale> // <locale>
// class money_put<charT, OutputIterator> // class money_put<charT, OutputIterator>
// iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, // iter_type put(iter_type s, bool intl, ios_base& f, char_type fill,
// long double units) const; // long double units) const;
▲ Show 20 Lines • Show All 514 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.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_MONETARY at the moment // NetBSD does not support LC_MONETARY at the moment
// XFAIL: netbsd // XFAIL: netbsd
// XFAIL: LIBCXX-WINDOWS-FIXME // XFAIL: LIBCXX-WINDOWS-FIXME
// TODO(mordante): Investigate these localization/format failures since updating the Docker image in CI
// UNSUPPORTED: stdlib=libc++
// 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>
// class moneypunct_byname<charT, International> // class moneypunct_byname<charT, International>
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.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_NUMERIC at the moment // NetBSD does not support LC_NUMERIC at the moment
// XFAIL: netbsd // XFAIL: netbsd
// XFAIL: LIBCXX-WINDOWS-FIXME // XFAIL: LIBCXX-WINDOWS-FIXME
// TODO(mordante): Investigate these localization/format failures since updating the Docker image in CI
// UNSUPPORTED: stdlib=libc++
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// REQUIRES: locale.fr_FR.UTF-8 // REQUIRES: locale.fr_FR.UTF-8
// <locale> // <locale>
// template <class charT> class numpunct_byname; // template <class charT> class numpunct_byname;
// char_type thousands_sep() const; // char_type thousands_sep() const;
▲ Show 20 Lines • Show All 69 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: libcpp-has-no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
// template <class F, class... Args> // template <class F, class... Args>
// future<typename result_of<F(Args...)>::type> // future<typename result_of<F(Args...)>::type>
▲ Show 20 Lines • Show All 136 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: libcpp-has-no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// void wait() const; // void wait() const;
#include <future> #include <future>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 74 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: libcpp-has-no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// template <class Rep, class Period> // template <class Rep, class Period>
// future_status // future_status
// wait_for(const chrono::duration<Rep, Period>& rel_time) const; // wait_for(const chrono::duration<Rep, Period>& rel_time) const;
▲ Show 20 Lines • Show All 127 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: libcpp-has-no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <future> // <future>
// class shared_future<R> // class shared_future<R>
// template <class Clock, class Duration> // template <class Clock, class Duration>
// future_status // future_status
// wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; // wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
▲ Show 20 Lines • Show All 108 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: libcpp-has-no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <future> // <future>
// class future<R> // class future<R>
// void wait() const; // void wait() const;
#include <future> #include <future>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 50 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: libcpp-has-no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <future> // <future>
// class future<R> // class future<R>
// template <class Rep, class Period> // template <class Rep, class Period>
// future_status // future_status
// wait_for(const chrono::duration<Rep, Period>& rel_time) const; // wait_for(const chrono::duration<Rep, Period>& rel_time) const;
▲ Show 20 Lines • Show All 68 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: libcpp-has-no-threads
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <future> // <future>
// class future<R> // class future<R>
// template <class Clock, class Duration> // template <class Clock, class Duration>
// future_status // future_status
// wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; // wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <barrier> // <barrier>
#include <barrier> #include <barrier>
#include <thread> #include <thread>
#include "make_test_thread.h" #include "make_test_thread.h"
#include "test_macros.h" #include "test_macros.h"
Show All 15 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <barrier> // <barrier>
#include <barrier> #include <barrier>
#include <thread> #include <thread>
#include <cassert> #include <cassert>
#include "make_test_thread.h" #include "make_test_thread.h"
#include "test_macros.h" #include "test_macros.h"
Show All 14 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <barrier> // <barrier>
#include <barrier> #include <barrier>
#include <thread> #include <thread>
#include "make_test_thread.h" #include "make_test_thread.h"
#include "test_macros.h" #include "test_macros.h"
Show All 14 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <barrier> // <barrier>
#include <barrier> #include <barrier>
#include <thread> #include <thread>
#include <cassert> #include <cassert>
#include "make_test_thread.h" #include "make_test_thread.h"
#include "test_macros.h" #include "test_macros.h"
Show All 19 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: libcpp-has-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
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <condition_variable> // <condition_variable>
// void // void
// notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); // notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 31 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: libcpp-has-no-threads
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// void notify_all(); // void notify_all();
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// template <class Rep, class Period> // template <class Rep, class Period>
// cv_status // cv_status
// wait_for(unique_lock<mutex>& lock, // wait_for(unique_lock<mutex>& lock,
// const chrono::duration<Rep, Period>& rel_time); // const chrono::duration<Rep, Period>& rel_time);
▲ Show 20 Lines • Show All 76 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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
// wait_for(unique_lock<mutex>& lock, // wait_for(unique_lock<mutex>& lock,
// const chrono::duration<Rep, Period>& rel_time, // const chrono::duration<Rep, Period>& rel_time,
▲ Show 20 Lines • Show All 82 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <condition_variable> // <condition_variable>
// class condition_variable; // class condition_variable;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// cv_status // cv_status
// wait_until(unique_lock<mutex>& lock, // wait_until(unique_lock<mutex>& lock,
// const chrono::time_point<Clock, Duration>& abs_time); // const chrono::time_point<Clock, Duration>& abs_time);
▲ Show 20 Lines • Show All 99 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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
// wait_until(unique_lock<mutex>& lock, // wait_until(unique_lock<mutex>& lock,
// const chrono::time_point<Clock, Duration>& abs_time, // const chrono::time_point<Clock, Duration>& abs_time,
▲ Show 20 Lines • Show All 99 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <condition_variable> // <condition_variable>
// class condition_variable_any; // class condition_variable_any;
// void notify_one(); // void notify_one();
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 84 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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
// wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time); // wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
▲ Show 20 Lines • Show All 79 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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
// wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, // wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time,
// Predicate pred); // Predicate pred);
▲ Show 20 Lines • Show All 88 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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
// wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time); // wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time);
▲ Show 20 Lines • Show All 91 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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
// wait_until(Lock& lock, // wait_until(Lock& lock,
// const chrono::time_point<Clock, Duration>& abs_time, // const chrono::time_point<Clock, Duration>& abs_time,
▲ Show 20 Lines • Show All 103 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <latch> // <latch>
#include <latch> #include <latch>
#include <thread> #include <thread>
#include "make_test_thread.h" #include "make_test_thread.h"
#include "test_macros.h" #include "test_macros.h"
Show All 12 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <latch> // <latch>
#include <latch> #include <latch>
#include <thread> #include <thread>
#include "make_test_thread.h" #include "make_test_thread.h"
#include "test_macros.h" #include "test_macros.h"
Show All 13 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// 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}}
// ALLOW_RETRIES: 2 // TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// explicit shared_lock(mutex_type& m); // explicit shared_lock(mutex_type& m);
// template<class _Mutex> shared_lock(shared_lock<_Mutex>) // template<class _Mutex> shared_lock(shared_lock<_Mutex>)
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class timed_mutex; // class timed_mutex;
// template <class Rep, class Period> // template <class Rep, class Period>
// shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time); // shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 78 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time); // shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 70 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// 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}}
// ALLOW_RETRIES: 2 // TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// shared_lock(mutex_type& m, try_to_lock_t); // shared_lock(mutex_type& m, try_to_lock_t);
#include <shared_mutex> #include <shared_mutex>
▲ Show 20 Lines • Show All 55 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// 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}}
// ALLOW_RETRIES: 2 // TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// void lock(); // void lock();
#include <shared_mutex> #include <shared_mutex>
▲ Show 20 Lines • Show All 76 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <shared_mutex> #include <shared_mutex>
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
// template<class _Mutex> unique_lock(unique_lock<_Mutex>) // template<class _Mutex> unique_lock(unique_lock<_Mutex>)
// -> unique_lock<_Mutex>; // C++17 // -> unique_lock<_Mutex>; // C++17
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 54 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 54 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <mutex> #include <mutex>
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 50 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// template <class Mutex> class unique_lock; // template <class Mutex> class unique_lock;
// void lock(); // void lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
▲ 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: libcpp-has-no-threads
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// class mutex; // class mutex;
// void lock(); // void lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 34 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: libcpp-has-no-threads
//
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// class mutex; // class mutex;
// bool try_lock(); // bool try_lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 38 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// class recursive_mutex; // class recursive_mutex;
// void lock(); // void lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 36 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// class recursive_mutex; // class recursive_mutex;
// bool try_lock(); // bool try_lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 40 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_mutex; // class shared_mutex;
// void lock(); // void lock();
#include <shared_mutex> #include <shared_mutex>
#include <thread> #include <thread>
▲ 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/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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_mutex; // class shared_mutex;
// void lock_shared(); // void lock_shared();
#include <shared_mutex> #include <shared_mutex>
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 69 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_mutex; // class shared_mutex;
// bool try_lock(); // bool try_lock();
#include <shared_mutex> #include <shared_mutex>
#include <thread> #include <thread>
Show All 38 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_mutex; // class shared_mutex;
// bool try_lock_shared(); // bool try_lock_shared();
#include <shared_mutex> #include <shared_mutex>
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// void lock(); // void lock();
#include <thread> #include <thread>
▲ 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/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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// void lock_shared(); // void lock_shared();
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 82 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// bool try_lock(); // bool try_lock();
#include <shared_mutex> #include <shared_mutex>
#include <thread> #include <thread>
Show All 38 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_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);
#include <shared_mutex> #include <shared_mutex>
▲ Show 20 Lines • Show All 65 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// bool try_lock_shared(); // bool try_lock_shared();
#include <shared_mutex> #include <shared_mutex>
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 49 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// template <class Rep, class Period> // template <class Rep, class Period>
// bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time); // bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
#include <shared_mutex> #include <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_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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// template <class Clock, class Duration> // template <class Clock, class Duration>
// bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time); // bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 70 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_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);
#include <shared_mutex> #include <shared_mutex>
▲ Show 20 Lines • Show All 65 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: libcpp-has-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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
#include <shared_mutex> #include <shared_mutex>
#include <atomic> #include <atomic>
#include <chrono> #include <chrono>
▲ 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/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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// void lock(); // void lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 34 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// class timed_mutex; // class timed_mutex;
// bool try_lock(); // bool try_lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 38 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 53 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// class recursive_timed_mutex; // class recursive_timed_mutex;
// void lock(); // void lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 36 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <mutex> // <mutex>
// class recursive_timed_mutex; // class recursive_timed_mutex;
// bool try_lock(); // bool try_lock();
#include <mutex> #include <mutex>
#include <thread> #include <thread>
Show All 40 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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <mutex> #include <mutex>
▲ 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/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: libcpp-has-no-threads
// ALLOW_RETRIES: 2 // ALLOW_RETRIES: 2
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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);
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <semaphore> // <semaphore>
#include <semaphore> #include <semaphore>
#include <chrono> #include <chrono>
#include <thread> #include <thread>
#include <type_traits> #include <type_traits>
#include "make_test_thread.h" #include "make_test_thread.h"
Show All 23 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <semaphore> // <semaphore>
#include <semaphore> #include <semaphore>
#include <thread> #include <thread>
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "make_test_thread.h" #include "make_test_thread.h"
Show All 27 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: libcpp-has-no-threads
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// This test requires the dylib support introduced in D68480, which shipped in // This test requires the dylib support introduced in D68480, which shipped in
// macOS 11.0. // 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <semaphore> // <semaphore>
#include <cassert> #include <cassert>
#include <semaphore> #include <semaphore>
#include <thread> #include <thread>
#include "make_test_thread.h" #include "make_test_thread.h"
#include "test_macros.h" #include "test_macros.h"
Show All 17 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: libcpp-has-no-threads
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <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>
#include <cassert> #include <cassert>
Show All 17 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-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: libcpp-has-no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO(mordante): Investigate these localization/format failures since updating the Docker image in CI
// UNSUPPORTED: stdlib=libc++
// 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
// basic_format_context(Out out, // basic_format_context(Out out,
// basic_format_args<basic_format_context> args, // basic_format_args<basic_format_context> args,
▲ Show 20 Lines • Show All 121 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-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: libcpp-has-no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO(mordante): Investigate these localization/format failures since updating the Docker image in CI
// UNSUPPORTED: stdlib=libc++
// 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();
#include <format> #include <format>
▲ Show 20 Lines • Show All 76 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-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-localization // UNSUPPORTED: libcpp-has-no-localization
// UNSUPPORTED: libcpp-has-no-incomplete-format // UNSUPPORTED: libcpp-has-no-incomplete-format
// TODO(mordante): Investigate these localization/format failures since updating the Docker image in CI
// UNSUPPORTED: stdlib=libc++
// REQUIRES: locale.en_US.UTF-8 // REQUIRES: locale.en_US.UTF-8
// <format> // <format>
// This test the locale-specific form for these formatting functions: // This test the locale-specific form for these formatting functions:
// //
// // [format.functions], formatting functions // // [format.functions], formatting functions
// template<class... Args> // template<class... Args>
▲ Show 20 Lines • Show All 605 Lines • Show Last 20 Lines

libcxx/test/std/utilities/time/time.clock/time.clock.hires/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <chrono> // <chrono>
// high_resolution_clock // high_resolution_clock
// static time_point now(); // static time_point now();
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
Show All 13 Lines

libcxx/test/std/utilities/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: libcpp-has-no-filesystem-library
// 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}}
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <chrono> // <chrono>
// file_clock // file_clock
// static time_point now() noexcept; // static time_point now() noexcept;
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
Show All 15 Lines

libcxx/test/std/utilities/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: libcpp-has-no-monotonic-clock
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <chrono> // <chrono>
// steady_clock // steady_clock
// static time_point now(); // static time_point now();
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
Show All 14 Lines

libcxx/test/std/utilities/time/time.clock/time.clock.system/from_time_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <chrono> // <chrono>
// system_clock // system_clock
// static time_point from_time_t(time_t t); // static time_point from_time_t(time_t t);
#include <chrono> #include <chrono>
#include <ctime> #include <ctime>
Show All 11 Lines

libcxx/test/std/utilities/time/time.clock/time.clock.system/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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <chrono> // <chrono>
// system_clock // system_clock
// static time_point now(); // static time_point now();
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
Show All 13 Lines

libcxx/test/std/utilities/time/time.clock/time.clock.system/to_time_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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
// <chrono> // <chrono>
// system_clock // system_clock
// time_t to_time_t(const time_point& t); // time_t to_time_t(const time_point& t);
#include <chrono> #include <chrono>
#include <ctime> #include <ctime>
Show All 11 Lines

libcxxabi/test/test_exception_storage.pass.cpp

//===-------------------- test_exception_storage.cpp ----------------------===// //===-------------------- test_exception_storage.cpp ----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TODO(ldionne): This test fails on Ubuntu Focal on our CI nodes (and only there), in 32 bit mode.
// UNSUPPORTED: linux && 32bits-on-64bits
#include <algorithm> #include <algorithm>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <__threading_support> #include <__threading_support>
#include <unistd.h> #include <unistd.h>
#include "../src/cxa_exception.h" #include "../src/cxa_exception.h"
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libunwind/test/remember_state_leak.pass.sh.s

# REQUIRES: target={{x86_64-.+-linux-gnu}} # REQUIRES: target={{x86_64-.+-linux-gnu}}
# RUN: %{build} # RUN: %{build}
# RUN: %{run} # RUN: %{run}
// TODO: Investigate these failures // TODO: Investigate these failures
// XFAIL: asan, tsan, ubsan // XFAIL: asan, tsan, ubsan
// TODO: Investigate this failure // TODO: Investigate this failure
// XFAIL: 32bits-on-64bits // XFAIL: 32bits-on-64bits
# TODO: Investigate this failure on GCC.
# XFAIL: gcc
# The following assembly is a translation of this code: # The following assembly is a translation of this code:
# #
# _Unwind_Reason_Code callback(int, _Unwind_Action, long unsigned int, # _Unwind_Reason_Code callback(int, _Unwind_Action, long unsigned int,
# _Unwind_Exception*, _Unwind_Context*, void*) { # _Unwind_Exception*, _Unwind_Context*, void*) {
# return _Unwind_Reason_Code(0); # return _Unwind_Reason_Code(0);
# } # }
# #
# int main() { # int main() {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines