Protect lock tests under libcpp-no-exceptions

[rogfer01]

Summary

Skip tests that expect an exception to be thrown.

[mclow.lists]

This looks OK to me.

libcxx/trunk/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // This test hangs forever when built against libstdc++. In order to allow
 // validation of the test suite against other STLs we have to mark it
 // unsupported.
 // UNSUPPORTED: libstdc++
 
 // <mutex>
 
 // template <class L1, class L2, class... L3>
 //   void lock(L1&, L2&, L3&...);
 
 #include <mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 class L0
 {
     bool locked_;
 
 public:
     L0() : locked_(false) {}
 
     void lock()

 {
     bool locked_;
 
 public:
     L2() : locked_(false) {}
 
     void lock()
     {
-        throw 1;
+        TEST_THROW(1);
     }
 
     bool try_lock()
     {
-        throw 1;
+        TEST_THROW(1);
         return locked_;
     }
 
     void unlock() {locked_ = false;}
 
     bool locked() const {return locked_;}
 };
 
int main()
     }
     {
         L1 l0;
         L0 l1;
         std::lock(l0, l1);
         assert(l0.locked());
         assert(l1.locked());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L2 l1;
         try
         {
             std::lock(l0, l1);
             assert(false);
         }
#ifndef TEST_HAS_NO_EXCEPTIONS
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
         }
     }
+#endif
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     {
         L0 l0;
         L0 l1;
         L0 l2;
         std::lock(l0, l1, l2);
         assert(l0.locked());
         assert(l1.locked());
         assert(l2.locked());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L2 l0;
         L2 l1;
         L2 l2;
         try
         {
             std::lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
+#endif
     {
         L0 l0;
         L0 l1;
         L1 l2;
         std::lock(l0, l1, l2);
         assert(l0.locked());
         assert(l1.locked());
         assert(l2.locked());
#endif
         L1 l0;
         L0 l1;
         L0 l2;
         std::lock(l0, l1, l2);
         assert(l0.locked());
         assert(l1.locked());
         assert(l2.locked());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L0 l1;
         L2 l2;
         try
         {
             std::lock(l0, l1, l2);
             assert(false);
#ifndef TEST_HAS_NO_EXCEPTIONS
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
+#endif  // TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L0 l1;
         L0 l2;
         L0 l3;
         std::lock(l0, l1, l2, l3);
         assert(l0.locked());
         assert(l1.locked());
#endif  // TEST_HAS_NO_EXCEPTIONS
         L0 l2;
         L0 l3;
         std::lock(l0, l1, l2, l3);
         assert(l0.locked());
         assert(l1.locked());
         assert(l2.locked());
         assert(l3.locked());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L0 l1;
         L0 l2;
         L2 l3;
         try
         {
             std::lock(l0, l1, l2, l3);
#ifndef TEST_HAS_NO_EXCEPTIONS
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
             assert(!l3.locked());
         }
     }
+#endif  // TEST_HAS_NO_EXCEPTIONS
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // template <class L1, class L2, class... L3>
 //   int try_lock(L1&, L2&, L3&...);
 
 #include <mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 class L0
 {
     bool locked_;
 
 public:
     L0() : locked_(false) {}
 
     bool try_lock()

 {
     bool locked_;
 
 public:
     L2() : locked_(false) {}
 
     bool try_lock()
     {
-        throw 1;
+        TEST_THROW(1);
         return locked_;
     }
 
     void unlock() {locked_ = false;}
 
     bool locked() const {return locked_;}
 };
 
int main()
     }
     {
         L1 l0;
         L0 l1;
         assert(std::try_lock(l0, l1) == 0);
         assert(!l0.locked());
         assert(!l1.locked());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L2 l1;
         try
         {
             std::try_lock(l0, l1);
             assert(false);
         }
#ifndef TEST_HAS_NO_EXCEPTIONS
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
         }
     }
+#endif
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     {
         L0 l0;
         L0 l1;
         L0 l2;
         assert(std::try_lock(l0, l1, l2) == -1);
         assert(l0.locked());
         assert(l1.locked());
         assert(l2.locked());
     }
     {
         L1 l0;
         L1 l1;
         L1 l2;
         assert(std::try_lock(l0, l1, l2) == 0);
         assert(!l0.locked());
         assert(!l1.locked());
         assert(!l2.locked());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L2 l0;
         L2 l1;
         L2 l2;
         try
         {
             std::try_lock(l0, l1, l2);
             assert(false);
#ifndef TEST_HAS_NO_EXCEPTIONS
         L0 l0;
         L1 l1;
         L2 l2;
         assert(std::try_lock(l0, l1, l2) == 1);
         assert(!l0.locked());
         assert(!l1.locked());
         assert(!l2.locked());
     }
+#endif
     {
         L0 l0;
         L0 l1;
         L1 l2;
         assert(std::try_lock(l0, l1, l2) == 2);
         assert(!l0.locked());
         assert(!l1.locked());
         assert(!l2.locked());
#endif
         L1 l0;
         L0 l1;
         L0 l2;
         assert(std::try_lock(l0, l1, l2) == 0);
         assert(!l0.locked());
         assert(!l1.locked());
         assert(!l2.locked());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L0 l1;
         L2 l2;
         try
         {
             std::try_lock(l0, l1, l2);
             assert(false);
#ifndef TEST_HAS_NO_EXCEPTIONS
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
+#endif
     {
         L1 l0;
         L1 l1;
         L0 l2;
         assert(std::try_lock(l0, l1, l2) == 0);
         assert(!l0.locked());
         assert(!l1.locked());
         assert(!l2.locked());
#endif
         L0 l0;
         L1 l1;
         L1 l2;
         assert(std::try_lock(l0, l1, l2) == 1);
         assert(!l0.locked());
         assert(!l1.locked());
         assert(!l2.locked());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L1 l0;
         L1 l1;
         L2 l2;
         assert(std::try_lock(l0, l1, l2) == 0);
         assert(!l0.locked());
         assert(!l1.locked());
         assert(!l2.locked());
#ifndef TEST_HAS_NO_EXCEPTIONS
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
+#endif  // TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L0 l1;
         L0 l2;
         L0 l3;
         assert(std::try_lock(l0, l1, l2, l3) == -1);
         assert(l0.locked());
         assert(l1.locked());

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // void lock();

 {
     std::shared_lock<std::shared_timed_mutex> lk(m, std::defer_lock);
     time_point t0 = Clock::now();
     lk.lock();
     time_point t1 = Clock::now();
     assert(lk.owns_lock() == true);
     ns d = t1 - t0 - WaitTime;
     assert(d < Tolerance);  // within tolerance
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
+#endif
     lk.unlock();
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }
 
 int main()
 {
     m.lock();
     std::vector<std::thread> v;
     for (int i = 0; i < 5; ++i)
         v.push_back(std::thread(f));
     std::this_thread::sleep_for(WaitTime);
     m.unlock();
     for (auto& t : v)
         t.join();
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // bool try_lock();
 
 #include <shared_mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 bool try_lock_called = false;
 
 struct mutex
 {
     bool try_lock_shared()
     {
         try_lock_called = !try_lock_called;
         return try_lock_called;
     }
     void unlock_shared() {}
 };
 
 mutex m;
 
 int main()
 {
-
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
     assert(try_lock_called == true);
     assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
+#endif
     lk.unlock();
     assert(lk.try_lock() == false);
     assert(try_lock_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // template <class Rep, class Period>
 //   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 
 #include <shared_mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 bool try_lock_for_called = false;
 
 typedef std::chrono::milliseconds ms;
 
 struct mutex
 {
     template <class Rep, class Period>
         bool try_lock_shared_for(const std::chrono::duration<Rep, Period>& rel_time)
     {
         assert(rel_time == ms(5));
         try_lock_for_called = !try_lock_for_called;
         return try_lock_for_called;
     }
     void unlock_shared() {}
 };
 
 mutex m;
 
 int main()
 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
     assert(try_lock_for_called == true);
     assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
+#endif
     lk.unlock();
     assert(lk.try_lock_for(ms(5)) == false);
     assert(try_lock_for_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // template <class Clock, class Duration>
 //   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 
 #include <shared_mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 bool try_lock_until_called = false;
 
 struct mutex
 {
     template <class Clock, class Duration>
         bool try_lock_shared_until(const std::chrono::time_point<Clock, Duration>& abs_time)
     {
         typedef std::chrono::milliseconds ms;
         assert(Clock::now() - abs_time < ms(5));
         try_lock_until_called = !try_lock_until_called;
         return try_lock_until_called;
     }
     void unlock_shared() {}
 };
 
 mutex m;
 
 int main()
 {
     typedef std::chrono::steady_clock Clock;
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_until(Clock::now()) == true);
     assert(try_lock_until_called == true);
     assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
+#endif
     lk.unlock();
     assert(lk.try_lock_until(Clock::now()) == false);
     assert(try_lock_until_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // void unlock();
 
 #include <shared_mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 bool unlock_called = false;
 
 struct mutex
 {
     void lock_shared() {}
     void unlock_shared() {unlock_called = true;}
 };
 
 mutex m;
 
 int main()
 {
     std::shared_lock<mutex> lk(m);
     lk.unlock();
     assert(unlock_called == true);
     assert(lk.owns_lock() == false);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.unlock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.unlock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // void lock();
 
 #include <mutex>
 #include <thread>
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 std::mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef std::chrono::milliseconds ms;
 typedef std::chrono::nanoseconds ns;
 
 void f()
 {
     std::unique_lock<std::mutex> lk(m, std::defer_lock);
     time_point t0 = Clock::now();
     lk.lock();
     time_point t1 = Clock::now();
     assert(lk.owns_lock() == true);
     ns d = t1 - t0 - ms(250);
     assert(d < ms(25));  // within 25ms
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
+#endif
     lk.unlock();
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }
 
 int main()
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // bool try_lock();
 
 #include <mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 bool try_lock_called = false;
 
 struct mutex
 {
     bool try_lock()
     {
         try_lock_called = !try_lock_called;
         return try_lock_called;
     }
     void unlock() {}
 };
 
 mutex m;
 
 int main()
 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
     assert(try_lock_called == true);
     assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
+#endif
     lk.unlock();
     assert(lk.try_lock() == false);
     assert(try_lock_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // template <class Rep, class Period>
 //   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 
 #include <mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 bool try_lock_for_called = false;
 
 typedef std::chrono::milliseconds ms;
 
 struct mutex
 {
     template <class Rep, class Period>
         bool try_lock_for(const std::chrono::duration<Rep, Period>& rel_time)
     {
         assert(rel_time == ms(5));
         try_lock_for_called = !try_lock_for_called;
         return try_lock_for_called;
     }
     void unlock() {}
 };
 
 mutex m;
 
 int main()
 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
     assert(try_lock_for_called == true);
     assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
+#endif
     lk.unlock();
     assert(lk.try_lock_for(ms(5)) == false);
     assert(try_lock_for_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // template <class Clock, class Duration>
 //   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 
 #include <mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 bool try_lock_until_called = false;
 
 struct mutex
 {
     template <class Clock, class Duration>
         bool try_lock_until(const std::chrono::time_point<Clock, Duration>& abs_time)
     {
         typedef std::chrono::milliseconds ms;
         assert(Clock::now() - abs_time < ms(5));
         try_lock_until_called = !try_lock_until_called;
         return try_lock_until_called;
     }
     void unlock() {}
 };
 
 mutex m;
 
 int main()
 {
     typedef std::chrono::steady_clock Clock;
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_until(Clock::now()) == true);
     assert(try_lock_until_called == true);
     assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
+#endif
     lk.unlock();
     assert(lk.try_lock_until(Clock::now()) == false);
     assert(try_lock_until_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // void unlock();
 
 #include <mutex>
 #include <cassert>
 
+#include "test_macros.h"
+
 bool unlock_called = false;
 
 struct mutex
 {
     void lock() {}
     void unlock() {unlock_called = true;}
 };
 
 mutex m;
 
 int main()
 {
     std::unique_lock<mutex> lk(m);
     lk.unlock();
     assert(unlock_called == true);
     assert(lk.owns_lock() == false);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.unlock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
     lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         lk.unlock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
+#endif
 }

libcxx/trunk/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // struct once_flag;
 
 // template<class Callable, class ...Args>
 //   void call_once(once_flag& flag, Callable&& func, Args&&... args);

 int init3_called = 0;
 int init3_completed = 0;
 
 void init3()
 {
     ++init3_called;
     std::this_thread::sleep_for(ms(250));
     if (init3_called == 1)
-        throw 1;
+        TEST_THROW(1);
     ++init3_completed;
 }
 
 void f3()
 {
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         std::call_once(flg3, init3);
     }
     catch (...)
     {
     }
+#endif
 }
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 struct init1
 {
     static int called;
 
int main()
     // check basic functionality
     {
         std::thread t0(f0);
         std::thread t1(f0);
         t0.join();
         t1.join();
         assert(init0_called == 1);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     // check basic exception safety
     {
         std::thread t0(f3);
         std::thread t1(f3);
         t0.join();
         t1.join();
         assert(init3_called == 2);
         assert(init3_completed == 1);
     }
+#endif
     // check deadlock avoidance
     {
         std::thread t0(f41);
         std::thread t1(f42);
         t0.join();
         t1.join();
         assert(init41_called == 1);
         assert(init42_called == 1);