Avoid relying on timeouts in try_lock_until tests for lock types.

Directly compare the absolute timeouts that are passed to try_lock_until
calls with the expected values. This makes the tests more reliable.

Author: Lastique

test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp

@@ -22,6 +22,11 @@
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/chrono/time_point.hpp>
+#include <boost/chrono/system_clocks.hpp>
+
+typedef boost::chrono::steady_clock clock_type;
+clock_type::time_point g_abs_timeout;
 
 bool try_lock_until_called = false;
 
@@ -30,8 +35,7 @@ struct shared_mutex
   template <class Clock, class Duration>
   bool try_lock_shared_until(const boost::chrono::time_point<Clock, Duration>& abs_time)
   {
-    typedef boost::chrono::milliseconds ms;
-    BOOST_TEST(Clock::now() - abs_time < ms(5));
+    BOOST_TEST(abs_time == g_abs_timeout);
     try_lock_until_called = !try_lock_until_called;
     return try_lock_until_called;
   }
@@ -44,28 +48,31 @@ shared_mutex g_mutex;
 
 int main()
 {
-  typedef boost::chrono::steady_clock Clock;
   boost::shared_lock<shared_mutex> lk(g_mutex, boost::defer_lock);
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == true);
+  g_abs_timeout = clock_type::now();
+  BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == true);
   BOOST_TEST(try_lock_until_called == true);
   BOOST_TEST(lk.owns_lock() == true);
   try
   {
-    lk.try_lock_until(Clock::now());
+    g_abs_timeout = clock_type::now();
+    lk.try_lock_until((clock_type::time_point)g_abs_timeout);
     BOOST_TEST(false);
   }
   catch (boost::system::system_error& e)
   {
     BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
   }
   lk.unlock();
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == false);
+  g_abs_timeout = clock_type::now();
+  BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == false);
   BOOST_TEST(try_lock_until_called == false);
   BOOST_TEST(lk.owns_lock() == false);
   lk.release();
   try
   {
-    lk.try_lock_until(Clock::now());
+    g_abs_timeout = clock_type::now();
+    lk.try_lock_until((clock_type::time_point)g_abs_timeout);
     BOOST_TEST(false);
   }
   catch (boost::system::system_error& e)

test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp

@@ -25,6 +25,11 @@
 
 #if defined BOOST_THREAD_USES_CHRONO
 
+#include <boost/chrono/time_point.hpp>
+#include <boost/chrono/system_clocks.hpp>
+
+typedef boost::chrono::steady_clock clock_type;
+clock_type::time_point g_abs_timeout;
 
 bool try_lock_until_called = false;
 
@@ -33,8 +38,7 @@ struct mutex
   template <class Clock, class Duration>
   bool try_lock_until(const boost::chrono::time_point<Clock, Duration>& abs_time)
   {
-    typedef boost::chrono::milliseconds ms;
-    BOOST_TEST(Clock::now() - abs_time < ms(5));
+    BOOST_TEST(abs_time == g_abs_timeout);
     try_lock_until_called = !try_lock_until_called;
     return try_lock_until_called;
   }
@@ -47,28 +51,31 @@ mutex g_mutex;
 
 int main()
 {
-  typedef boost::chrono::steady_clock Clock;
   boost::unique_lock<mutex> lk(g_mutex, boost::defer_lock);
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == true);
+  g_abs_timeout = clock_type::now();
+  BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == true);
   BOOST_TEST(try_lock_until_called == true);
   BOOST_TEST(lk.owns_lock() == true);
   try
   {
-    lk.try_lock_until(Clock::now());
+    g_abs_timeout = clock_type::now();
+    lk.try_lock_until((clock_type::time_point)g_abs_timeout);
     BOOST_TEST(false);
   }
   catch (boost::system::system_error& e)
   {
     BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
   }
   lk.unlock();
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == false);
+  g_abs_timeout = clock_type::now();
+  BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == false);
   BOOST_TEST(try_lock_until_called == false);
   BOOST_TEST(lk.owns_lock() == false);
   lk.release();
   try
   {
-    lk.try_lock_until(Clock::now());
+    g_abs_timeout = clock_type::now();
+    lk.try_lock_until((clock_type::time_point)g_abs_timeout);
     BOOST_TEST(false);
   }
   catch (boost::system::system_error& e)
@@ -81,4 +88,3 @@ int main()
 #else
 #error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
 #endif
-

test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_until_pass.cpp

@@ -22,6 +22,11 @@
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/chrono/time_point.hpp>
+#include <boost/chrono/system_clocks.hpp>
+
+typedef boost::chrono::steady_clock clock_type;
+clock_type::time_point g_abs_timeout;
 
 bool try_lock_until_called = false;
 
@@ -30,8 +35,7 @@ struct shared_mutex
   template <class Clock, class Duration>
   bool try_lock_upgrade_until(const boost::chrono::time_point<Clock, Duration>& abs_time)
   {
-    typedef boost::chrono::milliseconds ms;
-    BOOST_TEST(Clock::now() - abs_time < ms(5));
+    BOOST_TEST(abs_time == g_abs_timeout);
     try_lock_until_called = !try_lock_until_called;
     return try_lock_until_called;
   }
@@ -44,28 +48,31 @@ shared_mutex g_mutex;
 
 int main()
 {
-  typedef boost::chrono::steady_clock Clock;
   boost::upgrade_lock<shared_mutex> lk(g_mutex, boost::defer_lock);
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == true);
+  g_abs_timeout = clock_type::now();
+  BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == true);
   BOOST_TEST(try_lock_until_called == true);
   BOOST_TEST(lk.owns_lock() == true);
   try
   {
-    lk.try_lock_until(Clock::now());
+    g_abs_timeout = clock_type::now();
+    lk.try_lock_until((clock_type::time_point)g_abs_timeout);
     BOOST_TEST(false);
   }
   catch (boost::system::system_error& e)
   {
     BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
   }
   lk.unlock();
-  BOOST_TEST(lk.try_lock_until(Clock::now()) == false);
+  g_abs_timeout = clock_type::now();
+  BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == false);
   BOOST_TEST(try_lock_until_called == false);
   BOOST_TEST(lk.owns_lock() == false);
   lk.release();
   try
   {
-    lk.try_lock_until(Clock::now());
+    g_abs_timeout = clock_type::now();
+    lk.try_lock_until((clock_type::time_point)g_abs_timeout);
     BOOST_TEST(false);
   }
   catch (boost::system::system_error& e)