This is an archive of the discontinued LLVM Phabricator instance.

Paths

Table of Contentst

Differential D113280

[libc++] Remove UNSUPPORTEDs on 32 bit CI
AbandonedPublic

Authored by ldionne on Nov 5 2021, 7:28 AM.

Download Raw Diff

Details

Reviewers

None

Group Reviewers

Restricted Project
Restricted Project

Summary

After upgrading our Docker image, the 32 bit CI started failing, so we
added temporary annotations in the tests to get the CI green again. This
removes these annotations.

NOTE: For now, this doesn't fix the issue at all. I can't reproduce it locally so I'm going to try to reproduce it on the CI instead.

Diff Detail

Repository: rG LLVM Github Monorepo

Unit TestsFailed

	Time	Test
	2,450 ms	libcxx CI 32 bit > llvm-libc++-shared-cfg-in.libcxx/input_output/filesystems/class_directory_entry/directory_entry_mods::last_write_time.pass.cpp
	1,650 ms	libcxx CI 32 bit > llvm-libc++-shared-cfg-in.libcxx/thread/thread_condition::PR30202_notify_from_pthread_created_thread.pass.cpp
	1,480 ms	libcxx CI 32 bit > llvm-libc++-shared-cfg-in.libcxx/thread/thread_threads/thread_thread_this::sleep_for.pass.cpp
	1,490 ms	libcxx CI 32 bit > llvm-libc++-shared-cfg-in.libcxx/thread/thread_threads/thread_thread_this::sleep_for.signals.pass.cpp
	3,040 ms	libcxx CI 32 bit > llvm-libc++-shared-cfg-in.std/input_output/filesystems/fs_op_funcs/fs_op_copy_file::copy_file.pass.cpp
		View Full Test Results (79 Failed)

Event Timeline

ldionne requested review of this revision.Nov 5 2021, 7:28 AM

ldionne created this revision.

Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptNov 5 2021, 7:28 AM

Herald added a reviewer: Restricted Project. · View Herald Transcript

Herald added a reviewer: Restricted Project. · View Herald Transcript

Herald added a subscriber: libcxx-commits. · View Herald Transcript

Harbormaster completed remote builds in B132682: Diff 385065.Nov 5 2021, 9:00 AM

Abandoning since we're removing support for the 32 bit multilib build in favour of building for a real 32 bit triple. See D114473.

Revision Contents

Path

Size

libcxx/

test/

libcxx/

input.output/

filesystems/

class.directory_entry/

directory_entry.mods/

last_write_time.pass.cpp

3 lines

thread/

thread.condition/

PR30202_notify_from_pthread_created_thread.pass.cpp

3 lines

thread.threads/

thread.thread.this/

sleep_for.pass.cpp

3 lines

sleep_for.signals.pass.cpp

3 lines

std/

input.output/

filesystems/

fs.op.funcs/

fs.op.copy_file/

copy_file.pass.cpp

3 lines

fs.op.last_write_time/

last_write_time.pass.cpp

3 lines

thread/

futures/

futures.async/

3 lines

futures.shared_future/

3 lines

wait_for.pass.cpp

3 lines

wait_until.pass.cpp

3 lines

futures.unique_future/

3 lines

wait_for.pass.cpp

3 lines

wait_until.pass.cpp

3 lines

thread.barrier/

arrive.pass.cpp

3 lines

arrive_and_drop.pass.cpp

3 lines

arrive_and_wait.pass.cpp

3 lines

completion.pass.cpp

3 lines

thread.condition/

notify_all_at_thread_exit.pass.cpp

3 lines

thread.condition.condvar/

notify_all.pass.cpp

3 lines

wait_for.pass.cpp

3 lines

wait_for_pred.pass.cpp

3 lines

wait_until.pass.cpp

3 lines

wait_until_pred.pass.cpp

3 lines

thread.condition.condvarany/

notify_one.pass.cpp

3 lines

wait_for.pass.cpp

3 lines

wait_for_pred.pass.cpp

3 lines

wait_until.pass.cpp

3 lines

wait_until_pred.pass.cpp

3 lines

thread.latch/

arrive_and_wait.pass.cpp

3 lines

count_down.pass.cpp

3 lines

thread.mutex/

thread.lock/

thread.lock.shared/

thread.lock.shared.cons/

3 lines

mutex_duration.pass.cpp

3 lines

mutex_time_point.pass.cpp

3 lines

mutex_try_to_lock.pass.cpp

3 lines

thread.lock.shared.locking/

3 lines

try_lock_until.pass.cpp

3 lines

thread.lock.unique/

thread.lock.unique.cons/

3 lines

mutex_duration.pass.cpp

3 lines

mutex_time_point.pass.cpp

3 lines

mutex_try_to_lock.pass.cpp

3 lines

thread.lock.unique.locking/

3 lines

try_lock_until.pass.cpp

3 lines

thread.mutex.requirements/

thread.mutex.requirements.mutex/

thread.mutex.class/

3 lines

try_lock.pass.cpp

3 lines

thread.mutex.recursive/

3 lines

try_lock.pass.cpp

3 lines

thread.shared_mutex.requirements/

thread.shared_mutex.class/

3 lines

lock_shared.pass.cpp

3 lines

try_lock.pass.cpp

3 lines

try_lock_shared.pass.cpp

3 lines

thread.sharedtimedmutex.requirements/

thread.sharedtimedmutex.class/

3 lines

lock_shared.pass.cpp

3 lines

try_lock.pass.cpp

3 lines

try_lock_for.pass.cpp

3 lines

try_lock_shared.pass.cpp

3 lines

try_lock_shared_for.pass.cpp

3 lines

try_lock_shared_until.pass.cpp

3 lines

try_lock_until.pass.cpp

3 lines

try_lock_until_deadlock_bug.pass.cpp

3 lines

thread.timedmutex.requirements/

thread.timedmutex.class/

3 lines

try_lock.pass.cpp

3 lines

try_lock_for.pass.cpp

3 lines

try_lock_until.pass.cpp

3 lines

thread.timedmutex.recursive/

3 lines

try_lock.pass.cpp

3 lines

try_lock_for.pass.cpp

3 lines

try_lock_until.pass.cpp

3 lines

thread.semaphore/

acquire.pass.cpp

3 lines

binary.pass.cpp

3 lines

release.pass.cpp

3 lines

3 lines

try_acquire.pass.cpp

3 lines

thread.threads/

thread.thread.this/

sleep_until.pass.cpp

3 lines

utilities/

time/

time.clock/

time.clock.hires/

3 lines

time.clock.file/

3 lines

time.clock.steady/

3 lines

time.clock.system/

from_time_t.pass.cpp

3 lines

3 lines

to_time_t.pass.cpp

3 lines

libcxxabi/

test/

test_exception_storage.pass.cpp

3 lines

Diff 385065

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 622 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			// 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}}

	// 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>)
	// -> shared_lock<_Mutex>; // C++17			// -> shared_lock<_Mutex>; // C++17
	▲ Show 20 Lines • Show All 84 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			// 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}}

	// 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>
	#include <thread>			#include <thread>
	▲ Show 20 Lines • Show All 54 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			// 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}}

	// 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>
	#include <thread>			#include <thread>
	▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.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/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 <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 13 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/release.pass.cpp

	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	//			//
	// UNSUPPORTED: libcpp-has-no-threads			// UNSUPPORTED: 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 "make_test_thread.h"			#include "make_test_thread.h"
	#include "test_macros.h"			#include "test_macros.h"

	Show All 16 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/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 58 Lines • Show Last 20 Lines