diff options
Diffstat (limited to 'test/std/thread/thread.threads/thread.thread.class')
25 files changed, 1280 insertions, 0 deletions
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp new file mode 100644 index 0000000000000..4d3a742dd168d --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// void swap(thread& x, thread& y); + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + G g; + std::thread t0(g); + std::thread::id id0 = t0.get_id(); + std::thread t1; + std::thread::id id1 = t1.get_id(); + swap(t0, t1); + assert(t0.get_id() == id1); + assert(t1.get_id() == id0); + t1.join(); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp new file mode 100644 index 0000000000000..7373886f6173d --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <thread> + +// class thread + +// thread& operator=(thread&& t); + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } + +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + std::thread t0(G()); + std::thread t1; + t1 = t0; + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp new file mode 100644 index 0000000000000..2db9430a698d9 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp @@ -0,0 +1,65 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// thread& operator=(thread&& t); + +#include <thread> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()(int i, double j) + { + assert(alive_ == 1); + assert(n_alive >= 1); + assert(i == 5); + assert(j == 5.5); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + assert(G::n_alive == 0); + assert(!G::op_run); + { + G g; + std::thread t0(g, 5, 5.5); + std::thread::id id = t0.get_id(); + std::thread t1; + t1 = std::move(t0); + assert(t1.get_id() == id); + assert(t0.get_id() == std::thread::id()); + t1.join(); + } + assert(G::n_alive == 0); + assert(G::op_run); + } +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp new file mode 100644 index 0000000000000..7198d226960a9 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// NOTE: std::terminate is called so the destructors are not invoked and the +// memory is not freed. This will cause ASAN to fail. +// XFAIL: asan + +// NOTE: TSAN will report this test as leaking a thread. +// XFAIL: tsan + +// <thread> + +// class thread + +// thread& operator=(thread&& t); + +#include <thread> +#include <exception> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } + + void operator()(int i, double j) + { + assert(alive_ == 1); + assert(n_alive >= 1); + assert(i == 5); + assert(j == 5.5); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +void f1() +{ + std::exit(0); +} + +int main() +{ + std::set_terminate(f1); + { + G g; + std::thread t0(g, 5, 5.5); + std::thread::id id = t0.get_id(); + std::thread t1; + t0 = std::move(t1); + assert(false); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp new file mode 100644 index 0000000000000..a8b4be16e631c --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp @@ -0,0 +1,154 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// template <class F, class ...Args> thread(F&& f, Args&&... args); + +// UNSUPPORTED: sanitizer-new-delete + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +unsigned throw_one = 0xFFFF; + +void* operator new(std::size_t s) throw(std::bad_alloc) +{ + if (throw_one == 0) + throw std::bad_alloc(); + --throw_one; + return std::malloc(s); +} + +void operator delete(void* p) throw() +{ + std::free(p); +} + +bool f_run = false; + +void f() +{ + f_run = true; +} + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } + + void operator()(int i, double j) + { + assert(alive_ == 1); + assert(n_alive >= 1); + assert(i == 5); + assert(j == 5.5); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +#ifndef _LIBCPP_HAS_NO_VARIADICS + +class MoveOnly +{ + MoveOnly(const MoveOnly&); +public: + MoveOnly() {} + MoveOnly(MoveOnly&&) {} + + void operator()(MoveOnly&&) + { + } +}; + +#endif + +int main() +{ + { + std::thread t(f); + t.join(); + assert(f_run == true); + } + f_run = false; + { + try + { + throw_one = 0; + std::thread t(f); + assert(false); + } + catch (...) + { + throw_one = 0xFFFF; + assert(!f_run); + } + } + { + assert(G::n_alive == 0); + assert(!G::op_run); + std::thread t((G())); + t.join(); + assert(G::n_alive == 0); + assert(G::op_run); + } + G::op_run = false; + { + try + { + throw_one = 0; + assert(G::n_alive == 0); + assert(!G::op_run); + std::thread t((G())); + assert(false); + } + catch (...) + { + throw_one = 0xFFFF; + assert(G::n_alive == 0); + assert(!G::op_run); + } + } +#ifndef _LIBCPP_HAS_NO_VARIADICS + { + assert(G::n_alive == 0); + assert(!G::op_run); + std::thread t(G(), 5, 5.5); + t.join(); + assert(G::n_alive == 0); + assert(G::op_run); + } + { + std::thread t = std::thread(MoveOnly(), MoveOnly()); + t.join(); + } +#endif // _LIBCPP_HAS_NO_VARIADICS +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp new file mode 100644 index 0000000000000..a331add962635 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <thread> + +// class thread +// template <class _Fp, class ..._Args, +// explicit thread(_Fp&& __f, _Args&&... __args); +// This constructor shall not participate in overload resolution +// if decay<F>::type is the same type as std::thread. + + +#include <thread> +#include <cassert> + +int main() +{ + volatile std::thread t1; + std::thread t2 ( t1, 1, 2.0 ); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp new file mode 100644 index 0000000000000..f66474c93b42b --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <thread> + +// class thread + +// thread(const thread&) = delete; + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } + + void operator()(int i, double j) + { + assert(alive_ == 1); + assert(n_alive >= 1); + assert(i == 5); + assert(j == 5.5); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + assert(G::n_alive == 0); + assert(!G::op_run); + std::thread t0(G(), 5, 5.5); + std::thread::id id = t0.get_id(); + std::thread t1 = t0; + assert(t1.get_id() == id); + assert(t0.get_id() == std::thread::id()); + t1.join(); + assert(G::n_alive == 0); + assert(G::op_run); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp new file mode 100644 index 0000000000000..64d5a935ba556 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// thread(); + +#include <thread> +#include <cassert> + +int main() +{ + std::thread t; + assert(t.get_id() == std::thread::id()); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp new file mode 100644 index 0000000000000..e88304ec8da9d --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// thread(thread&& t); + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } + + void operator()(int i, double j) + { + assert(alive_ == 1); + assert(n_alive >= 1); + assert(i == 5); + assert(j == 5.5); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + G g; + assert(G::n_alive == 1); + assert(!G::op_run); + std::thread t0(g, 5, 5.5); + std::thread::id id = t0.get_id(); + std::thread t1 = std::move(t0); + assert(t1.get_id() == id); + assert(t0.get_id() == std::thread::id()); + t1.join(); + assert(G::n_alive == 1); + assert(G::op_run); + } + assert(G::n_alive == 0); +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp new file mode 100644 index 0000000000000..ddf96d0957306 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// NOTE: TSAN will report this test as leaking a thread. +// XFAIL: tsan + +// <thread> + +// class thread + +// ~thread(); + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +void f1() +{ + std::exit(0); +} + +int main() +{ + std::set_terminate(f1); + { + assert(G::n_alive == 0); + assert(!G::op_run); + G g; + { + std::thread t(g); + std::this_thread::sleep_for(std::chrono::milliseconds(250)); + } + } + assert(false); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp new file mode 100644 index 0000000000000..585f7ea98a030 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp @@ -0,0 +1,29 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread::id + +// id& operator=(const id&) = default; + +#include <thread> +#include <cassert> + +int main() +{ + std::thread::id id0; + std::thread::id id1; + id1 = id0; + assert(id1 == id0); + id1 = std::this_thread::get_id(); + assert(id1 != id0); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp new file mode 100644 index 0000000000000..e8c38016b2886 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread::id + +// id(const id&) = default; + +#include <thread> +#include <cassert> + +int main() +{ + std::thread::id id0; + std::thread::id id1 = id0; + assert(id1 == id0); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp new file mode 100644 index 0000000000000..0037deb1dd655 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread::id + +// id(); + +#include <thread> +#include <cassert> + +int main() +{ + std::thread::id id; + assert(id == std::thread::id()); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp new file mode 100644 index 0000000000000..6dd4c3ec4f570 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp @@ -0,0 +1,32 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread::id + +// bool operator==(thread::id x, thread::id y); +// bool operator!=(thread::id x, thread::id y); + +#include <thread> +#include <cassert> + +int main() +{ + std::thread::id id0; + std::thread::id id1; + id1 = id0; + assert( (id1 == id0)); + assert(!(id1 != id0)); + id1 = std::this_thread::get_id(); + assert(!(id1 == id0)); + assert( (id1 != id0)); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp new file mode 100644 index 0000000000000..de52b1d00cdf3 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread::id + +// bool operator< (thread::id x, thread::id y); +// bool operator<=(thread::id x, thread::id y); +// bool operator> (thread::id x, thread::id y); +// bool operator>=(thread::id x, thread::id y); + +#include <thread> +#include <cassert> + +int main() +{ + std::thread::id id0; + std::thread::id id1; + std::thread::id id2 = std::this_thread::get_id(); + assert(!(id0 < id1)); + assert( (id0 <= id1)); + assert(!(id0 > id1)); + assert( (id0 >= id1)); + assert(!(id0 == id2)); + if (id0 < id2) { + assert( (id0 <= id2)); + assert(!(id0 > id2)); + assert(!(id0 >= id2)); + } else { + assert(!(id0 <= id2)); + assert( (id0 > id2)); + assert( (id0 >= id2)); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp new file mode 100644 index 0000000000000..126965fe3fc38 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp @@ -0,0 +1,29 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread::id + +// template<class charT, class traits> +// basic_ostream<charT, traits>& +// operator<<(basic_ostream<charT, traits>& out, thread::id id); + +#include <thread> +#include <sstream> +#include <cassert> + +int main() +{ + std::thread::id id0 = std::this_thread::get_id(); + std::ostringstream os; + os << id0; +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp new file mode 100644 index 0000000000000..106c69e2e4a1f --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp @@ -0,0 +1,35 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <functional> + +// template <class T> +// struct hash +// : public unary_function<T, size_t> +// { +// size_t operator()(T val) const; +// }; + +// Not very portable + +#include <thread> +#include <cassert> + +int main() +{ + std::thread::id id1; + std::thread::id id2 = std::this_thread::get_id(); + typedef std::hash<std::thread::id> H; + static_assert((std::is_same<typename H::argument_type, std::thread::id>::value), "" ); + static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" ); + H h; + assert(h(id1) != h(id2)); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp new file mode 100644 index 0000000000000..f4a4d1f777f1e --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// void detach(); + +#include <thread> +#include <atomic> +#include <cassert> + +std::atomic_bool done = ATOMIC_VAR_INIT(false); + +class G +{ + int alive_; + bool done_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1), done_(false) + { + ++n_alive; + } + + G(const G& g) : alive_(g.alive_), done_(false) + { + ++n_alive; + } + ~G() + { + alive_ = 0; + --n_alive; + if (done_) done = true; + } + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + done_ = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + G g; + std::thread t0(g); + assert(t0.joinable()); + t0.detach(); + assert(!t0.joinable()); + while (!done) {} + assert(G::op_run); + assert(G::n_alive == 1); + } + assert(G::n_alive == 0); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp new file mode 100644 index 0000000000000..5cca7b0b66b8c --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// id get_id() const; + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + G g; + std::thread t0(g); + std::thread::id id0 = t0.get_id(); + std::thread t1; + std::thread::id id1 = t1.get_id(); + assert(t0.get_id() != id1); + assert(t1.get_id() == std::thread::id()); + t0.join(); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp new file mode 100644 index 0000000000000..0512e49dcb336 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// void join(); + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + G g; + std::thread t0(g); + assert(t0.joinable()); + t0.join(); + assert(!t0.joinable()); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp new file mode 100644 index 0000000000000..b97839c321847 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// bool joinable() const; + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + G g; + std::thread t0(g); + assert(t0.joinable()); + t0.join(); + assert(!t0.joinable()); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp new file mode 100644 index 0000000000000..c8807a965c44b --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// native_handle_type native_handle(); + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + G g; + std::thread t0(g); + pthread_t pid = t0.native_handle(); + assert(pid != 0); + t0.join(); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp new file mode 100644 index 0000000000000..49d4618e86adc --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// void swap(thread& t); + +#include <thread> +#include <new> +#include <cstdlib> +#include <cassert> + +class G +{ + int alive_; +public: + static int n_alive; + static bool op_run; + + G() : alive_(1) {++n_alive;} + G(const G& g) : alive_(g.alive_) {++n_alive;} + ~G() {alive_ = 0; --n_alive;} + + void operator()() + { + assert(alive_ == 1); + assert(n_alive >= 1); + op_run = true; + } +}; + +int G::n_alive = 0; +bool G::op_run = false; + +int main() +{ + { + G g; + std::thread t0(g); + std::thread::id id0 = t0.get_id(); + std::thread t1; + std::thread::id id1 = t1.get_id(); + t0.swap(t1); + assert(t0.get_id() == id1); + assert(t1.get_id() == id0); + t1.join(); + } +} diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp new file mode 100644 index 0000000000000..4d1ffad459377 --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread + +// unsigned hardware_concurrency(); + +#include <thread> +#include <cassert> + +int main() +{ + assert(std::thread::hardware_concurrency() > 0); +} diff --git a/test/std/thread/thread.threads/thread.thread.class/types.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/types.pass.cpp new file mode 100644 index 0000000000000..a5bf77031ccaf --- /dev/null +++ b/test/std/thread/thread.threads/thread.thread.class/types.pass.cpp @@ -0,0 +1,27 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads + +// <thread> + +// class thread +// { +// public: +// typedef pthread_t native_handle_type; +// ... +// }; + +#include <thread> +#include <type_traits> + +int main() +{ + static_assert((std::is_same<std::thread::native_handle_type, pthread_t>::value), ""); +} |