diff options
Diffstat (limited to 'libcxx/test/std/thread/thread.condition')
5 files changed, 142 insertions, 130 deletions
diff --git a/libcxx/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp b/libcxx/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp index 2b8772f92ed..3292d8bdc57 100644 --- a/libcxx/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp +++ b/libcxx/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp @@ -36,9 +36,10 @@ void func() int main() { std::unique_lock<std::mutex> lk(mut); - std::thread(func).detach(); + std::thread t(func); Clock::time_point t0 = Clock::now(); cv.wait(lk); Clock::time_point t1 = Clock::now(); assert(t1-t0 > ms(250)); + t.join(); } diff --git a/libcxx/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp b/libcxx/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp index 6236a13df80..1341e90a885 100644 --- a/libcxx/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp +++ b/libcxx/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp @@ -20,12 +20,13 @@ #include <thread> #include <cassert> +#include "test_atomic.h" + std::condition_variable cv; std::mutex mut; -int test0 = 0; -int test1 = 0; -int test2 = 0; +AtomicInt test1(0); +AtomicInt test2(0); void f1() { @@ -64,11 +65,13 @@ int main() } if (test1 == 2) { + assert(test2 == 1); t1.join(); test1 = 0; } else if (test2 == 2) { + assert(test1 == 1); t2.join(); test2 = 0; } @@ -81,11 +84,13 @@ int main() } if (test1 == 2) { + assert(test2 == 0); t1.join(); test1 = 0; } else if (test2 == 2) { + assert(test1 == 0); t2.join(); test2 = 0; } diff --git a/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait.exception.pass.cpp b/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait.exception.pass.cpp deleted file mode 100644 index 522c61b02d1..00000000000 --- a/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait.exception.pass.cpp +++ /dev/null @@ -1,63 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 - -#include <thread> -#include <condition_variable> -#include <mutex> -#include <chrono> -#include <iostream> -#include <cassert> - -void f1() -{ - std::exit(0); -} - -struct Mutex -{ - unsigned state = 0; - Mutex() = default; - ~Mutex() = default; - Mutex(const Mutex&) = delete; - Mutex& operator=(const Mutex&) = delete; - - void lock() - { - if (++state == 2) - throw 1; // this throw should end up calling terminate() - } - - void unlock() {} -}; - -Mutex mut; -std::condition_variable_any cv; - -void -signal_me() -{ - std::this_thread::sleep_for(std::chrono::milliseconds(500)); - cv.notify_one(); -} - -int -main() -{ - std::set_terminate(f1); - try - { - std::thread(signal_me).detach(); - mut.lock(); - cv.wait(mut); - } - catch (...) {} - assert(false); -} diff --git a/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.exception.pass.cpp b/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.exception.pass.cpp deleted file mode 100644 index 1906b589250..00000000000 --- a/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.exception.pass.cpp +++ /dev/null @@ -1,63 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 - -#include <thread> -#include <condition_variable> -#include <mutex> -#include <chrono> -#include <iostream> -#include <cassert> - -void f1() -{ - std::exit(0); -} - -struct Mutex -{ - unsigned state = 0; - Mutex() = default; - ~Mutex() = default; - Mutex(const Mutex&) = delete; - Mutex& operator=(const Mutex&) = delete; - - void lock() - { - if (++state == 2) - throw 1; // this throw should end up calling terminate() - } - - void unlock() {} -}; - -Mutex mut; -std::condition_variable_any cv; - -void -signal_me() -{ - std::this_thread::sleep_for(std::chrono::milliseconds(500)); - cv.notify_one(); -} - -int -main() -{ - std::set_terminate(f1); - try - { - std::thread(signal_me).detach(); - mut.lock(); - cv.wait_for(mut, std::chrono::milliseconds(250)); - } - catch (...) {} - assert(false); -} diff --git a/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp b/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp new file mode 100644 index 00000000000..ed8c55d176a --- /dev/null +++ b/libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp @@ -0,0 +1,132 @@ +//===----------------------------------------------------------------------===// +// +// 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 + +// <condition_variable> + +// class condition_variable_any; + +// RUN: %build +// RUN: %run 1 +// RUN: %run 2 +// RUN: %run 3 +// RUN: %run 4 +// RUN: %run 5 +// RUN: %run 6 + +// ----------------------------------------------------------------------------- +// Overview +// Check that std::terminate is called if wait(...) fails to meet it's post +// conditions. This can happens when reacquiring the mutex throws +// an exception. +// +// The following methods are tested within this file +// 1. void wait(Lock& lock); +// 2. void wait(Lock& lock, Pred); +// 3. void wait_for(Lock& lock, Duration); +// 4. void wait_for(Lock& lock, Duration, Pred); +// 5. void wait_until(Lock& lock, TimePoint); +// 6. void wait_until(Lock& lock, TimePoint, Pred); +// +// Plan +// 1 Create a mutex type, 'ThrowingMutex', that throws when the lock is aquired +// for the *second* time. +// +// 2 Replace the terminate handler with one that exits with a '0' exit code. +// +// 3 Create a 'condition_variable_any' object 'cv' and a 'ThrowingMutex' +// object 'm' and lock 'm'. +// +// 4 Start a thread 'T2' that will notify 'cv' once 'm' has been unlocked. +// +// 5 From the main thread call the specified wait method on 'cv' with 'm'. +// When 'T2' notifies 'cv' and the wait method attempts to re-lock +// 'm' an exception will be thrown from 'm.lock()'. +// +// 6 Check that control flow does not return from the wait method and that +// terminate is called (If the program exits with a 0 exit code we know +// that terminate has been called) + + +#include <condition_variable> +#include <thread> +#include <chrono> +#include <string> +#include <cstdlib> +#include <cassert> + +#include "test_atomic.h" + +void my_terminate() { + std::_Exit(0); // Use _Exit to prevent cleanup from taking place. +} + +// The predicate used in the cv.wait calls. +bool pred = false; +bool pred_function() { + return pred == true; +} + +class ThrowingMutex +{ + AtomicBool locked; + unsigned state = 0; + ThrowingMutex(const ThrowingMutex&) = delete; + ThrowingMutex& operator=(const ThrowingMutex&) = delete; +public: + ThrowingMutex() = default; + ~ThrowingMutex() = default; + + void lock() { + locked = true; + if (++state == 2) { + assert(pred); // Check that we actually waited until we were signaled. + throw 1; // this throw should end up calling terminate() + } + } + + void unlock() { locked = false; } + bool isLocked() const { return locked == true; } +}; + +ThrowingMutex mut; +std::condition_variable_any cv; + +void signal_me() { + while (mut.isLocked()) {} // wait until T1 releases mut inside the cv.wait call. + pred = true; + cv.notify_one(); +} + +typedef std::chrono::system_clock Clock; +typedef std::chrono::milliseconds MS; + +int main(int argc, char** argv) { + assert(argc == 2); + int id = std::stoi(argv[1]); + assert(id >= 1 && id <= 6); + std::set_terminate(my_terminate); // set terminate after std::stoi because it can throw. + MS wait(250); + try { + mut.lock(); + assert(pred == false); + std::thread(signal_me).detach(); + switch (id) { + case 1: cv.wait(mut); break; + case 2: cv.wait(mut, pred_function); break; + case 3: cv.wait_for(mut, wait); break; + case 4: cv.wait_for(mut, wait, pred_function); break; + case 5: cv.wait_until(mut, Clock::now() + wait); break; + case 6: cv.wait_until(mut, Clock::now() + wait, pred_function); break; + default: assert(false); + } + } catch (...) {} + assert(false); +} |
