diff options
Diffstat (limited to 'libcxx/test/thread')
11 files changed, 747 insertions, 2 deletions
diff --git a/libcxx/test/thread/futures/futures.atomic_future/copy_assign.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/copy_assign.pass.cpp new file mode 100644 index 00000000000..bd17f88d0d3 --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/copy_assign.pass.cpp @@ -0,0 +1,74 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// atomic_future& operator=(const atomic_future& rhs); + +#include <future> +#include <cassert> + +int main() +{ +#ifdef _LIBCPP_MOVE + { + typedef int T; + std::promise<T> p; + std::atomic_future<T> f0 = p.get_future(); + std::atomic_future<T> f; + f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef int T; + std::atomic_future<T> f0; + std::atomic_future<T> f; + f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef int& T; + std::promise<T> p; + std::atomic_future<T> f0 = p.get_future(); + std::atomic_future<T> f; + f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef int& T; + std::atomic_future<T> f0; + std::atomic_future<T> f; + f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef void T; + std::promise<T> p; + std::atomic_future<T> f0 = p.get_future(); + std::atomic_future<T> f; + f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef void T; + std::atomic_future<T> f0; + std::atomic_future<T> f; + f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } +#endif // _LIBCPP_MOVE +} diff --git a/libcxx/test/thread/futures/futures.atomic_future/copy_ctor.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/copy_ctor.pass.cpp new file mode 100644 index 00000000000..a4338129819 --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/copy_ctor.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// atomic_future(const atomic_future& rhs); + +#include <future> +#include <cassert> + +int main() +{ + { + typedef int T; + std::promise<T> p; + std::atomic_future<T> f0 = p.get_future(); + std::atomic_future<T> f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef int T; + std::atomic_future<T> f0; + std::atomic_future<T> f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef int& T; + std::promise<T> p; + std::atomic_future<T> f0 = p.get_future(); + std::atomic_future<T> f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef int& T; + std::atomic_future<T> f0; + std::atomic_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef void T; + std::promise<T> p; + std::atomic_future<T> f0 = p.get_future(); + std::atomic_future<T> f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef void T; + std::atomic_future<T> f0; + std::atomic_future<T> f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } +} diff --git a/libcxx/test/thread/futures/futures.atomic_future/ctor_future.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/ctor_future.pass.cpp new file mode 100644 index 00000000000..db0e4237ef2 --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/ctor_future.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// atomic_future(future<R>&& rhs); + +#include <future> +#include <cassert> + +int main() +{ + { + typedef int T; + std::promise<T> p; + std::future<T> f0 = p.get_future(); + std::atomic_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef int T; + std::future<T> f0; + std::atomic_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef int& T; + std::promise<T> p; + std::future<T> f0 = p.get_future(); + std::atomic_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef int& T; + std::future<T> f0; + std::atomic_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef void T; + std::promise<T> p; + std::future<T> f0 = p.get_future(); + std::atomic_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef void T; + std::future<T> f0; + std::atomic_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } +} diff --git a/libcxx/test/thread/futures/futures.atomic_future/default.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/default.pass.cpp new file mode 100644 index 00000000000..98d55044ae6 --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/default.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// atomic_future(); + +#include <future> +#include <cassert> + +int main() +{ + { + std::atomic_future<int> f; + assert(!f.valid()); + } + { + std::atomic_future<int&> f; + assert(!f.valid()); + } + { + std::atomic_future<void> f; + assert(!f.valid()); + } +} diff --git a/libcxx/test/thread/futures/futures.atomic_future/dtor.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/dtor.pass.cpp new file mode 100644 index 00000000000..a71b5230937 --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/dtor.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// ~atomic_future(); + +#include <future> +#include <cassert> + +#include "../test_allocator.h" + +int main() +{ + assert(test_alloc_base::count == 0); + { + typedef int T; + std::atomic_future<T> f; + { + std::promise<T> p(std::allocator_arg, test_allocator<T>()); + assert(test_alloc_base::count == 1); + f = p.get_future(); + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 0); + { + typedef int& T; + std::atomic_future<T> f; + { + std::promise<T> p(std::allocator_arg, test_allocator<int>()); + assert(test_alloc_base::count == 1); + f = p.get_future(); + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 0); + { + typedef void T; + std::atomic_future<T> f; + { + std::promise<T> p(std::allocator_arg, test_allocator<T>()); + assert(test_alloc_base::count == 1); + f = p.get_future(); + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 0); +} diff --git a/libcxx/test/thread/futures/futures.atomic_future/get.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/get.pass.cpp new file mode 100644 index 00000000000..db0ad955f7f --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/get.pass.cpp @@ -0,0 +1,143 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// const R& atomic_future::get(); +// R& atomic_future<R&>::get(); +// void atomic_future<void>::get(); + +#include <future> +#include <cassert> + +void func1(std::promise<int>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_value(3); +} + +void func2(std::promise<int>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_exception(std::make_exception_ptr(3)); +} + +int j = 0; + +void func3(std::promise<int&>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + j = 5; + p.set_value(j); +} + +void func4(std::promise<int&>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_exception(std::make_exception_ptr(3.5)); +} + +void func5(std::promise<void>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_value(); +} + +void func6(std::promise<void>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_exception(std::make_exception_ptr('c')); +} + +int main() +{ + { + typedef int T; + { + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func1, std::move(p)).detach(); + assert(f.valid()); + assert(f.get() == 3); + assert(f.valid()); + } + { + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func2, std::move(p)).detach(); + try + { + assert(f.valid()); + assert(f.get() == 3); + assert(false); + } + catch (int i) + { + assert(i == 3); + } + assert(f.valid()); + } + } + { + typedef int& T; + { + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func3, std::move(p)).detach(); + assert(f.valid()); + assert(f.get() == 5); + assert(f.valid()); + } + { + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func4, std::move(p)).detach(); + try + { + assert(f.valid()); + assert(f.get() == 3); + assert(false); + } + catch (double i) + { + assert(i == 3.5); + } + assert(f.valid()); + } + } + { + typedef void T; + { + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func5, std::move(p)).detach(); + assert(f.valid()); + f.get(); + assert(f.valid()); + } + { + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func6, std::move(p)).detach(); + try + { + assert(f.valid()); + f.get(); + assert(false); + } + catch (char i) + { + assert(i == 'c'); + } + assert(f.valid()); + } + } +} diff --git a/libcxx/test/thread/futures/futures.atomic_future/wait.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/wait.pass.cpp new file mode 100644 index 00000000000..b8810d26900 --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/wait.pass.cpp @@ -0,0 +1,86 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// void wait() const; + +#include <future> +#include <cassert> + +void func1(std::promise<int>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_value(3); +} + +int j = 0; + +void func3(std::promise<int&>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + j = 5; + p.set_value(j); +} + +void func5(std::promise<void>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_value(); +} + +int main() +{ + typedef std::chrono::high_resolution_clock Clock; + typedef std::chrono::duration<double, std::milli> ms; + { + typedef int T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func1, std::move(p)).detach(); + assert(f.valid()); + f.wait(); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef int& T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func3, std::move(p)).detach(); + assert(f.valid()); + f.wait(); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef void T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func5, std::move(p)).detach(); + assert(f.valid()); + f.wait(); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } +} diff --git a/libcxx/test/thread/futures/futures.atomic_future/wait_for.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/wait_for.pass.cpp new file mode 100644 index 00000000000..0a544ef9cc8 --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/wait_for.pass.cpp @@ -0,0 +1,95 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// template <class Rep, class Period> +// future_status +// wait_for(const chrono::duration<Rep, Period>& rel_time) const; + +#include <future> +#include <cassert> + +typedef std::chrono::milliseconds ms; + +void func1(std::promise<int>& p) +{ + std::this_thread::sleep_for(ms(500)); + p.set_value(3); +} + +int j = 0; + +void func3(std::promise<int&>& p) +{ + std::this_thread::sleep_for(ms(500)); + j = 5; + p.set_value(j); +} + +void func5(std::promise<void>& p) +{ + std::this_thread::sleep_for(ms(500)); + p.set_value(); +} + +int main() +{ + typedef std::chrono::high_resolution_clock Clock; + { + typedef int T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func1, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef int& T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func3, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef void T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func5, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } +} diff --git a/libcxx/test/thread/futures/futures.atomic_future/wait_until.pass.cpp b/libcxx/test/thread/futures/futures.atomic_future/wait_until.pass.cpp new file mode 100644 index 00000000000..e1270411fee --- /dev/null +++ b/libcxx/test/thread/futures/futures.atomic_future/wait_until.pass.cpp @@ -0,0 +1,95 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class atomic_future<R> + +// template <class Clock, class Duration> +// future_status +// wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; + +#include <future> +#include <cassert> + +typedef std::chrono::milliseconds ms; + +void func1(std::promise<int>& p) +{ + std::this_thread::sleep_for(ms(500)); + p.set_value(3); +} + +int j = 0; + +void func3(std::promise<int&>& p) +{ + std::this_thread::sleep_for(ms(500)); + j = 5; + p.set_value(j); +} + +void func5(std::promise<void>& p) +{ + std::this_thread::sleep_for(ms(500)); + p.set_value(); +} + +int main() +{ + typedef std::chrono::high_resolution_clock Clock; + { + typedef int T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func1, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef int& T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func3, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef void T; + std::promise<T> p; + std::atomic_future<T> f = p.get_future(); + std::thread(func5, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } +} diff --git a/libcxx/test/thread/thread.condition/notify_all_at_thread_exit.pass.cpp b/libcxx/test/thread/thread.condition/notify_all_at_thread_exit.pass.cpp index 6cc9067effc..6584a7712c2 100644 --- a/libcxx/test/thread/thread.condition/notify_all_at_thread_exit.pass.cpp +++ b/libcxx/test/thread/thread.condition/notify_all_at_thread_exit.pass.cpp @@ -13,9 +13,30 @@ // notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); #include <condition_variable> +#include <mutex> +#include <thread> +#include <chrono> #include <cassert> +std::condition_variable cv; +std::mutex mut; + +typedef std::chrono::milliseconds ms; +typedef std::chrono::high_resolution_clock Clock; + +void func() +{ + std::unique_lock<std::mutex> lk(mut); + std::notify_all_at_thread_exit(cv, std::move(lk)); + std::this_thread::sleep_for(ms(300)); +} + int main() { -#error notify_all_at_thread_exit not implemented + std::unique_lock<std::mutex> lk(mut); + std::thread(func).detach(); + Clock::time_point t0 = Clock::now(); + cv.wait(lk); + Clock::time_point t1 = Clock::now(); + assert(t1-t0 > ms(250)); } diff --git a/libcxx/test/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp b/libcxx/test/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp index a0e347db3e8..ac071d0ae88 100644 --- a/libcxx/test/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp +++ b/libcxx/test/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp @@ -61,7 +61,7 @@ void f() } else { - assert(t1 - t0 - milliseconds(250) < milliseconds(2)); + assert(t1 - t0 - milliseconds(250) < milliseconds(5)); assert(test2 == 0); } ++runs; |
