Skip tests that expect an exception to be thrown.
Differential Revision: https://reviews.llvm.org/D26184
llvm-svn: 285695
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// This test hangs forever when built against libstdc++. In order to allow
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
class L0
{
bool locked_;
void lock()
{
- throw 1;
+ TEST_THROW(1);
}
bool try_lock()
{
- throw 1;
+ TEST_THROW(1);
return locked_;
}
assert(l0.locked());
assert(l1.locked());
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
{
L0 l0;
L2 l1;
assert(!l1.locked());
}
}
+#endif
#ifndef _LIBCPP_HAS_NO_VARIADICS
{
L0 l0;
assert(l1.locked());
assert(l2.locked());
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
{
L2 l0;
L2 l1;
assert(!l2.locked());
}
}
+#endif
{
L0 l0;
L0 l1;
assert(l1.locked());
assert(l2.locked());
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
{
L0 l0;
L0 l1;
assert(!l2.locked());
}
}
+#endif // TEST_HAS_NO_EXCEPTIONS
{
L0 l0;
L0 l1;
assert(l2.locked());
assert(l3.locked());
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
{
L0 l0;
L0 l1;
assert(!l3.locked());
}
}
+#endif // TEST_HAS_NO_EXCEPTIONS
#endif // _LIBCPP_HAS_NO_VARIADICS
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// <mutex>
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
class L0
{
bool locked_;
bool try_lock()
{
- throw 1;
+ TEST_THROW(1);
return locked_;
}
assert(!l0.locked());
assert(!l1.locked());
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
{
L0 l0;
L2 l1;
assert(!l1.locked());
}
}
+#endif
#ifndef _LIBCPP_HAS_NO_VARIADICS
{
L0 l0;
assert(!l1.locked());
assert(!l2.locked());
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
{
L2 l0;
L2 l1;
assert(!l1.locked());
assert(!l2.locked());
}
+#endif
{
L0 l0;
L0 l1;
assert(!l1.locked());
assert(!l2.locked());
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
{
L0 l0;
L0 l1;
assert(!l2.locked());
}
}
+#endif
{
L1 l0;
L1 l1;
assert(!l1.locked());
assert(!l2.locked());
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
{
L1 l0;
L1 l1;
assert(!l2.locked());
}
}
+#endif // TEST_HAS_NO_EXCEPTIONS
{
L0 l0;
L0 l1;
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++98, c++03, c++11
assert(lk.owns_lock() == true);
ns d = t1 - t0 - WaitTime;
assert(d < Tolerance); // within tolerance
+#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
lk.lock();
{
assert(e.code().value() == EDEADLK);
}
+#endif
lk.unlock();
lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
lk.lock();
{
assert(e.code().value() == EPERM);
}
+#endif
}
int main()
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++98, c++03, c++11
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
bool try_lock_called = false;
struct mutex
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(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(e.code().value() == EPERM);
}
+#endif
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++98, c++03, c++11
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
bool try_lock_for_called = false;
typedef std::chrono::milliseconds ms;
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(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(e.code().value() == EPERM);
}
+#endif
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++98, c++03, c++11
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
bool try_lock_until_called = false;
struct mutex
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(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(e.code().value() == EPERM);
}
+#endif
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// UNSUPPORTED: c++98, c++03, c++11
#include <shared_mutex>
#include <cassert>
+#include "test_macros.h"
+
bool unlock_called = false;
struct mutex
lk.unlock();
assert(unlock_called == true);
assert(lk.owns_lock() == false);
+#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
lk.unlock();
{
assert(e.code().value() == EPERM);
}
+#endif
lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
lk.unlock();
{
assert(e.code().value() == EPERM);
}
+#endif
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// <mutex>
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
std::mutex m;
typedef std::chrono::system_clock Clock;
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(e.code().value() == EDEADLK);
}
+#endif
lk.unlock();
lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
lk.lock();
{
assert(e.code().value() == EPERM);
}
+#endif
}
int main()
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// <mutex>
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
bool try_lock_called = false;
struct mutex
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(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(e.code().value() == EPERM);
}
+#endif
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// <mutex>
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
bool try_lock_for_called = false;
typedef std::chrono::milliseconds ms;
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(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(e.code().value() == EPERM);
}
+#endif
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// <mutex>
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
bool try_lock_until_called = false;
struct mutex
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(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(e.code().value() == EPERM);
}
+#endif
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// <mutex>
#include <mutex>
#include <cassert>
+#include "test_macros.h"
+
bool unlock_called = false;
struct mutex
lk.unlock();
assert(unlock_called == true);
assert(lk.owns_lock() == false);
+#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
lk.unlock();
{
assert(e.code().value() == EPERM);
}
+#endif
lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
lk.unlock();
{
assert(e.code().value() == EPERM);
}
+#endif
}
//
//===----------------------------------------------------------------------===//
//
-// XFAIL: libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// <mutex>
++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
t1.join();
assert(init0_called == 1);
}
+#ifndef TEST_HAS_NO_EXCEPTIONS
// check basic exception safety
{
std::thread t0(f3);
assert(init3_called == 2);
assert(init3_completed == 1);
}
+#endif
// check deadlock avoidance
{
std::thread t0(f41);