Fix boost::detail::winapi references

fix static detection of lock-free atomic ints

build/Jamfile.v2

@@ -38,6 +38,8 @@ import path ;
 import configure ; 
 import threadapi-feature ;
 
+exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ;
+
 project boost/thread
     : source-location ../src
     : requirements <threading>multi
@@ -141,8 +143,6 @@ project boost/thread
       <library>/boost/system//boost_system
     ;
 
-exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ; 
-
 rule tag ( name : type ? : property-set )
 {
     local result = $(name) ;

circle.yml

@@ -0,0 +1,175 @@
+# Copyright 2018 Tom Hughes
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+build_steps: &build_steps
+  steps:
+    - run:
+        name: Setup
+        command: |
+          PLATFORM=`uname`
+          if [ "${PLATFORM}" == "Linux" ]; then
+            sudo apt-get install -y software-properties-common apt-transport-https
+
+            # https://github.com/ilikenwf/apt-fast
+            sudo add-apt-repository -y ppa:apt-fast/stable
+            sudo apt-get update
+            sudo apt-get -y install apt-fast
+
+            sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-4.0 main" | sudo tee -a /etc/apt/sources.list
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main" | sudo tee -a /etc/apt/sources.list
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-6.0 main" | sudo tee -a /etc/apt/sources.list
+            sudo apt-fast update
+            sudo apt-fast install -y $COMPILER
+          fi
+    - checkout
+    - run:
+        name: Install
+        command: |
+          BOOST_BRANCH=develop && [ "$CIRCLE_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          git submodule update --init tools/build
+          git submodule update --init libs/config
+          git submodule update --init tools/boostdep
+          mkdir -p libs/thread
+          cp -r $HOME/project/* libs/thread
+          python tools/boostdep/depinst/depinst.py thread
+          ./bootstrap.sh
+          ./b2 headers
+    - run:
+        name: Build
+        command: |
+          echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD <cxxflags>$DEFINES ;" > ~/user-config.jam
+          cd ../boost-root
+          ./b2 -j8 libs/thread/test toolset=$TOOLSET
+
+mac_build: &mac_build
+  macos:
+    xcode: "9.2.0"
+  <<: *build_steps
+
+linux_build: &linux_build
+  docker:
+    - image: circleci/buildpack-deps:trusty
+  <<: *build_steps
+
+
+version: 2
+jobs:
+  linux-g++-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++"
+      - CXXSTD: "c++11"
+
+  linux-g++-7-c++98:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++98"
+
+  linux-g++-7-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++11"
+
+  linux-g++-7-c++14:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++14"
+
+  linux-g++-7-c++1z:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++1z"
+
+  linux-clang++-4.0-c++98:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++98"
+
+  linux-clang++-4.0-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++11"
+
+  linux-clang++-4.0-c++14:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++14"
+
+  linux-clang++-4.0-c++1z:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++1z"
+
+  mac-clang++-c++98:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++98"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  mac-clang++-c++11:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++11"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  mac-clang++-c++14:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++14"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  mac-clang++-c++1z:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++1z"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+workflows:
+  version: 2
+  continous:
+    jobs:
+      - linux-g++-c++11
+      - linux-g++-7-c++98
+      - linux-g++-7-c++11
+      - linux-g++-7-c++14
+      - linux-g++-7-c++1z
+      - linux-clang++-4.0-c++98
+      - linux-clang++-4.0-c++11
+      - linux-clang++-4.0-c++14
+      - linux-clang++-4.0-c++1z
+      - mac-clang++-c++98
+      - mac-clang++-c++11
+      - mac-clang++-c++14
+      - mac-clang++-c++1z
+

doc/async_executors.qbk

@@ -1526,7 +1526,7 @@ A thread pool with up to a fixed number of threads.
 
 [variablelist
 
-[[Effects:] [Destroys the thread pool.]]
+[[Effects:] [Interrupts and joins all the threads and then destroys the threads.]]
 
 [[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
 

doc/changes.qbk

@@ -1,6 +1,6 @@
 [/
   (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-17 Vicente J. Botet Escriba.
+  (C) Copyright 2011-18 Vicente J. Botet Escriba.
   Distributed under the Boost Software License, Version 1.0.
   (See accompanying file LICENSE_1_0.txt or copy at
   http://www.boost.org/LICENSE_1_0.txt).
@@ -8,6 +8,27 @@
 
 [section:changes History]
 
+[heading Version 4.8.1 - boost 1.67]
+
+[*Know Bugs:]
+
+* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
+
+* [@http://svn.boost.org/trac/boost/ticket/10964 #10964] future<future<T>>::unwrap().then() Deadlocks
+
+
+Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
+
+Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread master regression test] to see the last regression test snapshot.
+
+[*Fixed Bugs:]
+
+
+* [@https://github.com/boostorg/thread/issues/162 #162] fix as much time-related issues as possible and improve the QOI
+* [@https://github.com/boostorg/thread/issues/193 #193] future_then unit test contains two different implementations of do_continuation function
+* [@https://github.com/boostorg/thread/issues/209 #209] Legal problem with `win32/thread_primitives.hpp`
+
+
 [heading Version 4.8.0 - boost 1.66]
 
 [*Know Bugs:]

include/boost/thread/detail/config.hpp

@@ -11,6 +11,7 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/thread/detail/platform.hpp>
+#include <boost/thread/detail/thread_safety.hpp>
 
 //#define BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
 // ATTRIBUTE_MAY_ALIAS
@@ -417,6 +418,11 @@
   #define BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
 #elif defined(BOOST_THREAD_CHRONO_MAC_API)
   #define BOOST_THREAD_HAS_MONO_CLOCK
+#elif defined(__ANDROID__)
+  #define BOOST_THREAD_HAS_MONO_CLOCK
+  #if defined(__ANDROID_API__) && __ANDROID_API__ >= 21
+    #define BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
+  #endif
 #else
   #include <time.h> // check for CLOCK_MONOTONIC
   #if defined(CLOCK_MONOTONIC)

include/boost/thread/detail/nullary_function.hpp

@@ -3,7 +3,7 @@
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
-// 2013/09 Vicente J. Botet Escriba
+// 2013,2018 Vicente J. Botet Escriba
 //    Adapt to boost from CCIA C++11 implementation
 //    Make use of Boost.Move
 
@@ -15,6 +15,7 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/csbl/memory/shared_ptr.hpp>
 #include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 namespace boost
 {
@@ -72,12 +73,16 @@ namespace boost
 
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
       template<typename F>
-      explicit nullary_function(F& f):
+      explicit nullary_function(F& f
+                                , typename disable_if<is_same<typename decay<F>::type, nullary_function>, int* >::type=0
+                                ):
       impl(new impl_type<F>(f))
       {}
 #endif
       template<typename F>
-      nullary_function(BOOST_THREAD_RV_REF(F) f):
+      nullary_function(BOOST_THREAD_RV_REF(F) f
+                       , typename disable_if<is_same<typename decay<F>::type, nullary_function>, int* >::type=0
+                       ):
       impl(new impl_type<typename decay<F>::type>(thread_detail::decay_copy(boost::forward<F>(f))))
       {}
 

include/boost/thread/detail/thread.hpp

@@ -594,7 +594,7 @@ namespace boost
 #endif
 
 #if defined BOOST_THREAD_USES_DATETIME
-        inline BOOST_SYMBOL_VISIBLE void sleep(xtime const& abs_time)
+        inline BOOST_SYMBOL_VISIBLE void sleep(::boost::xtime const& abs_time)
         {
             sleep(system_time(abs_time));
         }
@@ -811,6 +811,7 @@ namespace boost
         };
 
         void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
+//#ifndef BOOST_NO_EXCEPTIONS
         struct shared_state_base;
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
         inline void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
@@ -824,6 +825,7 @@ namespace boost
 #else
         void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as);
 #endif
+//#endif
     }
 
     namespace this_thread

include/boost/thread/detail/thread_safety.hpp

@@ -0,0 +1,151 @@
+#ifndef BOOST_THREAD_DETAIL_THREAD_SAFETY_HPP
+#define BOOST_THREAD_DETAIL_THREAD_SAFETY_HPP
+
+// See https://clang.llvm.org/docs/ThreadSafetyAnalysis.html
+
+// Un-comment to enable Thread Safety Analysis
+//#define BOOST_THREAD_ENABLE_THREAD_SAFETY_ANALYSIS
+
+// Enable thread safety attributes only with clang.
+// The attributes can be safely erased when compiling with other compilers.
+#if defined (BOOST_THREAD_ENABLE_THREAD_SAFETY_ANALYSIS) && defined(__clang__) && (!defined(SWIG))
+#define BOOST_THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
+#else
+#define BOOST_THREAD_ANNOTATION_ATTRIBUTE__(x)   // no-op
+#endif
+
+#define BOOST_THREAD_CAPABILITY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
+
+#define BOOST_THREAD_SCOPED_CAPABILITY \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+#define BOOST_THREAD_GUARDED_BY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+
+#define BOOST_THREAD_PT_GUARDED_BY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+#define BOOST_THREAD_ACQUIRED_BEFORE(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+#define BOOST_THREAD_ACQUIRED_AFTER(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define BOOST_THREAD_REQUIRES(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_REQUIRES_SHARED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_ACQUIRE(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_ACQUIRE_SHARED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_RELEASE(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_RELEASE_SHARED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_TRY_ACQUIRE(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_TRY_ACQUIRE_SHARED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_EXCLUDES(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+#define BOOST_THREAD_ASSERT_CAPABILITY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
+
+#define BOOST_THREAD_ASSERT_SHARED_CAPABILITY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
+
+#define BOOST_THREAD_RETURN_CAPABILITY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+#define BOOST_THREAD_NO_THREAD_SAFETY_ANALYSIS \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+
+#if defined(__clang__) && (!defined(SWIG)) && defined(__FreeBSD__)
+#if __has_attribute(no_thread_safety_analysis)
+#define BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis))
+#else
+#define BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+#endif
+#else
+#define BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+#endif
+
+#ifdef USE_LOCK_STYLE_THREAD_SAFETY_ATTRIBUTES
+// The original version of thread safety analysis the following attribute
+// definitions.  These use a lock-based terminology.  They are still in use
+// by existing thread safety code, and will continue to be supported.
+
+// Deprecated.
+#define BOOST_THREAD_PT_GUARDED_VAR \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var)
+
+// Deprecated.
+#define BOOST_THREAD_GUARDED_VAR \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(guarded_var)
+
+// Replaced by REQUIRES
+#define BOOST_THREAD_EXCLUSIVE_LOCKS_REQUIRED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+
+// Replaced by REQUIRES_SHARED
+#define BOOST_THREAD_SHARED_LOCKS_REQUIRED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+
+// Replaced by CAPABILITY
+#define BOOST_THREAD_LOCKABLE \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+
+// Replaced by SCOPED_CAPABILITY
+#define BOOST_THREAD_SCOPED_LOCKABLE \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+// Replaced by ACQUIRE
+#define BOOST_THREAD_EXCLUSIVE_LOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+
+// Replaced by ACQUIRE_SHARED
+#define BOOST_THREAD_SHARED_LOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+
+// Replaced by RELEASE and RELEASE_SHARED
+#define BOOST_THREAD_UNLOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+
+// Replaced by TRY_ACQUIRE
+#define BOOST_THREAD_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
+
+// Replaced by TRY_ACQUIRE_SHARED
+#define BOOST_THREAD_SHARED_TRYLOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+
+// Replaced by ASSERT_CAPABILITY
+#define BOOST_THREAD_ASSERT_EXCLUSIVE_LOCK(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
+
+// Replaced by ASSERT_SHARED_CAPABILITY
+#define BOOST_THREAD_ASSERT_SHARED_LOCK(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
+
+// Replaced by EXCLUDE_CAPABILITY.
+#define BOOST_THREAD_LOCKS_EXCLUDED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+// Replaced by RETURN_CAPABILITY
+#define BOOST_THREAD_LOCK_RETURNED(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+#endif  // USE_LOCK_STYLE_THREAD_SAFETY_ATTRIBUTES
+
+#endif  // BOOST_THREAD_DETAIL_THREAD_SAFETY_HPP

include/boost/thread/executors/basic_thread_pool.hpp

@@ -231,13 +231,36 @@ namespace executors
       // signal to all the worker threads that there will be no more submissions.
       close();
       // joins all the threads before destroying the thread pool resources (e.g. the queue).
-      join();
+      interrupt_and_join();
     }
 
     /**
      * \b Effects: join all the threads.
      */
     void join()
+    {
+      for (unsigned i = 0; i < threads.size(); ++i)
+      {
+        //threads[i].interrupt();
+        threads[i].join();
+      }
+    }
+
+    /**
+     * \b Effects: interrupt all the threads.
+     */
+    void interrupt()
+    {
+      for (unsigned i = 0; i < threads.size(); ++i)
+      {
+        threads[i].interrupt();
+      }
+    }
+
+    /**
+     * \b Effects: interrupt and join all the threads.
+     */
+    void interrupt_and_join()
     {
       for (unsigned i = 0; i < threads.size(); ++i)
       {

include/boost/thread/future.hpp

@@ -15,7 +15,16 @@
 
 //#define BOOST_THREAD_CONTINUATION_SYNC
 
-#ifndef BOOST_NO_EXCEPTIONS
+#ifdef BOOST_NO_EXCEPTIONS
+namespace boost
+{
+namespace detail {
+struct shared_state_base {
+    void notify_deferred() {}
+};
+}
+}
+#else
 
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/detail/move.hpp>

include/boost/thread/lock_guard.hpp

@@ -23,7 +23,7 @@ namespace boost
 {
 
   template <typename Mutex>
-  class lock_guard
+  class BOOST_THREAD_SCOPED_CAPABILITY lock_guard
   {
   private:
     Mutex& m;
@@ -32,13 +32,13 @@ namespace boost
     typedef Mutex mutex_type;
     BOOST_THREAD_NO_COPYABLE( lock_guard )
 
-    explicit lock_guard(Mutex& m_) :
+    explicit lock_guard(Mutex& m_) BOOST_THREAD_ACQUIRE(m_) :
       m(m_)
     {
       m.lock();
     }
 
-    lock_guard(Mutex& m_, adopt_lock_t) :
+    lock_guard(Mutex& m_, adopt_lock_t) BOOST_THREAD_REQUIRES(m_) :
       m(m_)
     {
 #if ! defined BOOST_THREAD_PROVIDES_NESTED_LOCKS
@@ -62,7 +62,7 @@ namespace boost
     }
 
 #endif
-    ~lock_guard()
+    ~lock_guard() BOOST_THREAD_RELEASE()
     {
       m.unlock();
     }

include/boost/thread/pthread/condition_variable.hpp

@@ -249,7 +249,7 @@ namespace boost
 #endif
         }
         template<typename lock_type>
-        bool timed_wait(lock_type& m,xtime const& abs_time)
+        bool timed_wait(lock_type& m,::boost::xtime const& abs_time)
         {
             return timed_wait(m,system_time(abs_time));
         }
@@ -309,7 +309,7 @@ namespace boost
         }
 
         template<typename lock_type,typename predicate_type>
-        bool timed_wait(lock_type& m,xtime const& abs_time, predicate_type pred)
+        bool timed_wait(lock_type& m,::boost::xtime const& abs_time, predicate_type pred)
         {
             return timed_wait(m,system_time(abs_time),pred);
         }

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -128,7 +128,7 @@ namespace boost
         }
         bool timed_wait(
             unique_lock<mutex>& m,
-            xtime const& abs_time)
+            ::boost::xtime const& abs_time)
         {
             return timed_wait(m,system_time(abs_time));
         }
@@ -194,7 +194,7 @@ namespace boost
         template<typename predicate_type>
         bool timed_wait(
             unique_lock<mutex>& m,
-            xtime const& abs_time,predicate_type pred)
+            ::boost::xtime const& abs_time,predicate_type pred)
         {
             return timed_wait(m,system_time(abs_time),pred);
         }

include/boost/thread/pthread/mutex.hpp

@@ -39,53 +39,8 @@
 
 namespace boost
 {
-  namespace posix {
-#ifdef BOOST_THREAD_HAS_EINTR_BUG
-    BOOST_FORCEINLINE int pthread_mutex_destroy(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_destroy(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-    BOOST_FORCEINLINE int pthread_mutex_lock(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_lock(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-    BOOST_FORCEINLINE int pthread_mutex_unlock(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_unlock(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-#else
-    BOOST_FORCEINLINE int pthread_mutex_destroy(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_destroy(m);
-    }
-    BOOST_FORCEINLINE int pthread_mutex_lock(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_lock(m);
-    }
-    BOOST_FORCEINLINE int pthread_mutex_unlock(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_unlock(m);
-    }
 
-#endif
-
-  }
-    class mutex
+    class BOOST_THREAD_CAPABILITY("mutex") mutex
     {
     private:
         pthread_mutex_t m;
@@ -107,7 +62,7 @@ namespace boost
           BOOST_ASSERT(!res);
         }
 
-        void lock()
+        void lock() BOOST_THREAD_ACQUIRE()
         {
             int res = posix::pthread_mutex_lock(&m);
             if (res)
@@ -116,7 +71,7 @@ namespace boost
             }
         }
 
-        void unlock()
+        void unlock() BOOST_THREAD_RELEASE()
         {
             int res = posix::pthread_mutex_unlock(&m);
             (void)res;
@@ -127,12 +82,12 @@ namespace boost
 //            }
         }
 
-        bool try_lock()
+        bool try_lock() BOOST_THREAD_TRY_ACQUIRE(true)
         {
             int res;
             do
             {
-                res = pthread_mutex_trylock(&m);
+                res = posix::pthread_mutex_trylock(&m);
             } while (res == EINTR);
             if (res==EBUSY)
             {
@@ -251,7 +206,7 @@ namespace boost
           int res;
           do
           {
-              res = pthread_mutex_trylock(&m);
+              res = posix::pthread_mutex_trylock(&m);
           } while (res == EINTR);
           if (res==EBUSY)
           {
@@ -277,7 +232,7 @@ namespace boost
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
             while(is_locked)
             {
-                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+                BOOST_VERIFY(!posix::pthread_cond_wait(&cond,&m));
             }
             is_locked=true;
         }
@@ -286,7 +241,7 @@ namespace boost
         {
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
             is_locked=false;
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_signal(&cond));
         }
 
         bool try_lock()

include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp

@@ -13,6 +13,75 @@
 
 namespace boost
 {
+namespace posix {
+#ifdef BOOST_THREAD_HAS_EINTR_BUG
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_destroy(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_destroy(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_lock(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_lock(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_unlock(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_unlock(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+#else
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_destroy(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_destroy(m);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_lock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_lock(m);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_unlock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_unlock(m);
+  }
+
+#endif
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_trylock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_trylock(m);
+  }
+
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+  {
+    return ::pthread_cond_wait(cond, mutex);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_cond_signal(pthread_cond_t *cond)
+  {
+    return ::pthread_cond_signal(cond);
+  }
+
+
+}
     namespace pthread
     {
         class pthread_mutex_scoped_lock
@@ -23,11 +92,11 @@ namespace boost
             explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
                 m(m_),locked(true)
             {
-                BOOST_VERIFY(!pthread_mutex_lock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_lock(m));
             }
             void unlock() BOOST_NOEXCEPT
             {
-                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                 locked=false;
             }
             void unlock_if_locked() BOOST_NOEXCEPT
@@ -54,11 +123,11 @@ namespace boost
             explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
                 m(m_)
             {
-                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
             }
             ~pthread_mutex_scoped_unlock() BOOST_NOEXCEPT
             {
-                BOOST_VERIFY(!pthread_mutex_lock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_lock(m));
             }
 
         };

include/boost/thread/pthread/recursive_mutex.hpp

@@ -105,17 +105,17 @@ namespace boost
 #ifdef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
         void lock()
         {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_unlock(&m));
         }
 
         bool try_lock() BOOST_NOEXCEPT
         {
-            int const res=pthread_mutex_trylock(&m);
+            int const res=posix::pthread_mutex_trylock(&m);
             BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }
@@ -270,17 +270,17 @@ namespace boost
 #ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
         void lock()
         {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_unlock(&m));
         }
 
         bool try_lock()
         {
-            int const res=pthread_mutex_trylock(&m);
+            int const res=posix::pthread_mutex_trylock(&m);
             BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }

include/boost/thread/pthread/thread_data.hpp

@@ -12,6 +12,7 @@
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/pthread/condition_variable_fwd.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
@@ -56,7 +57,7 @@ namespace boost
 #else
           std::size_t page_size = ::sysconf( _SC_PAGESIZE);
 #endif
-#ifdef PTHREAD_STACK_MIN
+#if PTHREAD_STACK_MIN > 0
           if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
 #endif
           size = ((size+page_size-1)/page_size)*page_size;
@@ -130,9 +131,10 @@ namespace boost
             > notify_list_t;
             notify_list_t notify;
 
+//#ifndef BOOST_NO_EXCEPTIONS
             typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
             async_states_t async_states_;
-
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             // These data must be at the end so that the access to the other fields doesn't change
             // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined.
@@ -148,8 +150,10 @@ namespace boost
                 cond_mutex(0),
                 current_cond(0),
 //#endif
-                notify(),
-                async_states_()
+                notify()
+//#ifndef BOOST_NO_EXCEPTIONS
+                , async_states_()
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 , interrupt_enabled(true)
                 , interrupt_requested(false)
@@ -165,11 +169,12 @@ namespace boost
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
 
+//#ifndef BOOST_NO_EXCEPTIONS
             void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
             {
               async_states_.push_back(as);
             }
-
+//#endif
         };
 
         BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
@@ -205,11 +210,11 @@ namespace boost
                     check_for_interruption();
                     thread_info->cond_mutex=cond_mutex;
                     thread_info->current_cond=cond;
-                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_lock(m));
                 }
                 else
                 {
-                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_lock(m));
                 }
             }
             void unlock_if_locked()
@@ -217,14 +222,14 @@ namespace boost
               if ( ! done) {
                 if (set)
                 {
-                    BOOST_VERIFY(!pthread_mutex_unlock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                     lock_guard<mutex> guard(thread_info->data_mutex);
                     thread_info->cond_mutex=NULL;
                     thread_info->current_cond=NULL;
                 }
                 else
                 {
-                    BOOST_VERIFY(!pthread_mutex_unlock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                 }
                 done = true;
               }

include/boost/thread/win32/basic_recursive_mutex.hpp

@@ -67,7 +67,7 @@ namespace boost
             template<typename Duration>
             bool timed_lock(Duration const& target)
             {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=boost::winapi::GetCurrentThreadId();
                 return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
             }
 #endif
@@ -76,13 +76,13 @@ namespace boost
             template <class Rep, class Period>
             bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
             {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=boost::winapi::GetCurrentThreadId();
                 return try_recursive_lock(current_thread_id) || try_timed_lock_for(current_thread_id,rel_time);
             }
             template <class Clock, class Duration>
             bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
             {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=boost::winapi::GetCurrentThreadId();
                 return try_recursive_lock(current_thread_id) || try_timed_lock_until(current_thread_id,t);
             }
 #endif

include/boost/thread/win32/thread_data.hpp

@@ -113,8 +113,10 @@ namespace boost
             > notify_list_t;
             notify_list_t notify;
 
+//#ifndef BOOST_NO_EXCEPTIONS
             typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
             async_states_t async_states_;
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             // These data must be at the end so that the access to the other fields doesn't change
             // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined
@@ -129,8 +131,10 @@ namespace boost
                 thread_exit_callbacks(0),
                 id(0),
                 tss_data(),
-                notify(),
-                async_states_()
+                notify()
+//#ifndef BOOST_NO_EXCEPTIONS
+                , async_states_()
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 , interruption_handle(create_anonymous_event(detail::win32::manual_reset_event,detail::win32::event_initially_reset))
                 , interruption_enabled(true)
@@ -166,11 +170,12 @@ namespace boost
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
 
+//#ifndef BOOST_NO_EXCEPTIONS
             void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
             {
               async_states_.push_back(as);
             }
-
+//#endif
         };
         BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
 

include/boost/thread/win32/thread_primitives.hpp

@@ -70,7 +70,7 @@ namespace boost
     {
         namespace win32
         {
-            namespace detail { typedef ticks_type (WINAPI *gettickcount64_t)(); }
+            namespace detail { typedef ticks_type (BOOST_WINAPI_WINAPI_CC *gettickcount64_t)(); }
             extern BOOST_THREAD_DECL boost::detail::win32::detail::gettickcount64_t gettickcount64;
 
             enum event_type

include/boost/thread/xtime.hpp

@@ -57,17 +57,17 @@ struct xtime
 
 };
 
-inline xtime get_xtime(boost::system_time const& abs_time)
+inline ::boost::xtime get_xtime(boost::system_time const& abs_time)
 {
-    xtime res;
+    ::boost::xtime res;
     boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
 
-    res.sec=static_cast<xtime::xtime_sec_t>(time_since_epoch.total_seconds());
-    res.nsec=static_cast<xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
+    res.sec=static_cast< ::boost::xtime::xtime_sec_t>(time_since_epoch.total_seconds());
+    res.nsec=static_cast< ::boost::xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
     return res;
 }
 
-inline int xtime_get(struct xtime* xtp, int clock_type)
+inline int xtime_get(struct ::boost::xtime* xtp, int clock_type)
 {
     if (clock_type == TIME_UTC_)
     {
@@ -78,7 +78,7 @@ inline int xtime_get(struct xtime* xtp, int clock_type)
 }
 
 
-inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
+inline int xtime_cmp(const ::boost::xtime& xt1, const ::boost::xtime& xt2)
 {
     if (xt1.sec == xt2.sec)
         return (int)(xt1.nsec - xt2.nsec);

src/future.cpp

@@ -4,8 +4,8 @@
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
 
+#ifndef BOOST_NO_EXCEPTIONS
 
 #include <boost/thread/futures/future_error_code.hpp>
 #include <string>

src/pthread/thread.cpp

@@ -27,9 +27,9 @@
 #include <unistd.h>
 #endif
 
-#if defined(__VXWORKS__) 
+#if defined(__VXWORKS__)
 #include <vxCpuLib.h>
-#endif 
+#endif
 
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
@@ -53,11 +53,13 @@ namespace boost
                 i->second->unlock();
                 i->first->notify_all();
             }
+//#ifndef BOOST_NO_EXCEPTIONS
             for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                     i != e; ++i)
             {
                 (*i)->notify_deferred();
             }
+//#endif
         }
 
         struct thread_exit_callback_node
@@ -213,8 +215,10 @@ namespace boost
             ~externally_launched_thread() {
               BOOST_ASSERT(notify.empty());
               notify.clear();
+//#ifndef BOOST_NO_EXCEPTIONS
               BOOST_ASSERT(async_states_.empty());
               async_states_.clear();
+//#endif
             }
             void run()
             {}
@@ -466,7 +470,7 @@ namespace boost
 #   elif defined(BOOST_HAS_PTHREAD_YIELD)
             BOOST_VERIFY(!pthread_yield());
 //#   elif defined BOOST_THREAD_USES_DATETIME
-//            xtime xt;
+//            ::boost::xtime xt;
 //            xtime_get(&xt, TIME_UTC_);
 //            sleep(xt);
 //            sleep_for(chrono::milliseconds(0));
@@ -474,7 +478,7 @@ namespace boost
             mutex mx;
             unique_lock<mutex> lock(mx);
             condition_variable cond;
-            cond.do_wait_until(lock, detail::internal_platform_clock::now())
+            cond.do_wait_until(lock, detail::internal_platform_clock::now());
 #   endif
         }
     }
@@ -498,9 +502,9 @@ namespace boost
            set &= set -1;
         }
         return(i);
-  #else  
+  #else
         return (__builtin_popcount(set) );
-  #endif  
+  #endif
 #elif defined(__GLIBC__)
         return get_nprocs();
 #else
@@ -773,6 +777,8 @@ namespace boost
         current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
       }
     }
+
+//#ifndef BOOST_NO_EXCEPTIONS
 namespace detail {
 
     void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
@@ -784,7 +790,7 @@ namespace detail {
       }
     }
 }
-
+//#endif
 
 
 }

src/win32/thread.cpp

@@ -54,11 +54,13 @@ namespace boost
             i->second->unlock();
             i->first->notify_all();
         }
+//#ifndef BOOST_NO_EXCEPTIONS
         for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                 i != e; ++i)
         {
             (*i)->notify_deferred();
         }
+//#endif
     }
   }
 
@@ -370,8 +372,10 @@ namespace boost
             ~externally_launched_thread() {
               BOOST_ASSERT(notify.empty());
               notify.clear();
+//#ifndef BOOST_NO_EXCEPTIONS
               BOOST_ASSERT(async_states_.empty());
               async_states_.clear();
+//#endif
             }
 
             void run()
@@ -518,12 +522,12 @@ namespace boost
         GetLogicalProcessorInformation(NULL, &size);
         if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
             return 0;
+        const size_t Elements = size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
 
-        std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(size);
+        std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(Elements);
         if (GetLogicalProcessorInformation(&buffer.front(), &size) == FALSE)
             return 0;
 
-        const size_t Elements = size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
 
         for (size_t i = 0; i < Elements; ++i) {
             if (buffer[i].Relationship == RelationProcessorCore)

src/win32/thread_primitives.cpp

@@ -93,8 +93,24 @@ ticks_type WINAPI get_tick_count_init()
     boost::winapi::HMODULE_ hKernel32 = boost::winapi::GetModuleHandleW(L"kernel32.dll");
     if (hKernel32)
     {
+      // GetProcAddress returns a pointer to some function. It can return
+      // pointers to different functions, so it has to return something that is
+      // suitable to store any pointer to function. Microsoft chose FARPROC,
+      // which is int (WINAPI *)() on 32-bit Windows. The user is supposed to
+      // know the signature of the function he requests and perform a cast
+      // (which is a nop on this platform). The result is a pointer to function
+      // with the required signature, which is bitwise equal to what
+      // GetProcAddress returned.
+      // However, gcc >= 8 warns about that.
+#if defined(BOOST_GCC) && BOOST_GCC >= 80000
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif
         boost::detail::win32::detail::gettickcount64_t p =
             (boost::detail::win32::detail::gettickcount64_t)boost::winapi::get_proc_address(hKernel32, "GetTickCount64");
+#if defined(BOOST_GCC) && BOOST_GCC >= 80000
+#pragma GCC diagnostic pop
+#endif
         if (p)
         {
             // Use native API

test/Jamfile.v2

@@ -208,6 +208,36 @@ rule thread-compile-fail ( sources : reqs * : name )
     ;
 }
 
+rule clang-thread-safety ( properties * )
+{
+    if <toolset>clang in $(properties)
+    {
+        return <cxxflags>-Werror=thread-safety  <define>BOOST_THREAD_ENABLE_THREAD_SAFETY_ANALYSIS ;
+    }
+    else
+    {
+        return <build>no ;
+    }
+}
+
+rule thread-safety-compile ( sources : reqs * : name )
+{
+    return
+    [ compile $(sources)
+        : $(reqs) <conditional>@clang-thread-safety
+        : $(name) ]
+    ;
+}
+
+rule thread-safety-compile-fail ( sources : reqs * : name )
+{
+    return
+    [ compile-fail $(sources)
+        : $(reqs) <conditional>@clang-thread-safety
+        : $(name) ]
+    ;
+}
+
 rule thread-compile ( sources : reqs * : name )
 {
     return
@@ -461,6 +491,10 @@ rule thread-compile ( sources : reqs * : name )
     :
           [ thread-compile-fail ./sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp : : lock_guard__cons__copy_assign_f ]
           [ thread-compile-fail ./sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp : : lock_guard__cons__copy_ctor_f ]
+          [ thread-safety-compile ./sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_pass.cpp : : lock_guard__lock_compile_p ]
+          [ thread-safety-compile-fail ./sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_fail.cpp : : lock_guard__lock_compile_f ]
+          [ thread-safety-compile ./sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_pass.cpp : : lock_guard__adopt_lock_compile_p ]
+          [ thread-safety-compile-fail ./sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_fail.cpp : : lock_guard__adopt_lock_compile_f ]
           [ thread-run2-noit ./sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp : lock_guard__cons__adopt_lock_p ]
           [ thread-run2-noit ./sync/mutual_exclusion/locks/lock_guard/default_pass.cpp : lock_guard__cons__default_p ]
           [ thread-run2-noit ./sync/mutual_exclusion/locks/lock_guard/types_pass.cpp : lock_guard__types_p ]
@@ -615,6 +649,12 @@ rule thread-compile ( sources : reqs * : name )
     :
           [ thread-compile-fail ./sync/mutual_exclusion/mutex/assign_fail.cpp : : mutex__assign_f ]
           [ thread-compile-fail ./sync/mutual_exclusion/mutex/copy_fail.cpp : : mutex__copy_f ]
+          [ thread-safety-compile ./sync/mutual_exclusion/mutex/lock_compile_pass.cpp : : mutex__lock_compile_p ]
+          [ thread-safety-compile-fail ./sync/mutual_exclusion/mutex/lock_compile_fail.cpp : : mutex__lock_compile_f ]
+          # https://bugs.llvm.org/show_bug.cgi?id=32954
+          # http://clang-developers.42468.n3.nabble.com/thread-safety-warnings-specifically-try-acquire-capability-td4059337.html
+          #[ thread-safety-compile ./sync/mutual_exclusion/mutex/try_lock_compile_pass.cpp : : mutex__try_lock_compile_p ]
+          [ thread-safety-compile-fail ./sync/mutual_exclusion/mutex/try_lock_compile_fail.cpp : : mutex__try_lock_compile_f ]
           [ thread-run2-noit ./sync/mutual_exclusion/mutex/default_pass.cpp : mutex__default_p ]
           [ thread-run2-noit ./sync/mutual_exclusion/mutex/lock_pass.cpp : mutex__lock_p ]
           [ thread-run2-noit-pthread ./sync/mutual_exclusion/mutex/native_handle_pass.cpp : mutex__native_handle_p ]
@@ -970,7 +1010,9 @@ rule thread-compile ( sources : reqs * : name )
           #[ thread-run test_11818.cpp ]
           #[ thread-run test_11796.cpp ]
           #[ thread-run test_12293.cpp ]
-          [ thread-run test_12949.cpp ]
+          #[ thread-run test_12949.cpp ]
+          #[ thread-run test_13480b.cpp ]
+          [ thread-run test_13561.cpp ]
           
     ;
 

test/sync/conditions/condition_variable/lost_notif_pass.cpp

@@ -237,5 +237,5 @@ int main()
     test_chrono_wait_function(wait_for_with_pred);
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

test/sync/conditions/condition_variable/wait_for_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <cassert>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -37,12 +38,10 @@ int runs = 0;
 typedef boost::chrono::steady_clock Clock;
 typedef boost::chrono::milliseconds milliseconds;
 typedef boost::chrono::nanoseconds nanoseconds;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {

test/sync/conditions/condition_variable/wait_for_pred_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <cassert>
 #include <iostream>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -51,12 +52,10 @@ int runs = 0;
 
 typedef boost::chrono::system_clock Clock;
 typedef boost::chrono::milliseconds milliseconds;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {

test/sync/conditions/condition_variable/wait_until_pass.cpp

@@ -23,9 +23,11 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <cassert>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
-
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 struct Clock
 {
   typedef boost::chrono::milliseconds duration;
@@ -44,16 +46,13 @@ struct Clock
 boost::condition_variable cv;
 boost::mutex mut;
 
+
 int test1 = 0;
 int test2 = 0;
 
 int runs = 0;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const Clock::duration max_diff(250);
-#else
-const Clock::duration max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -68,12 +67,14 @@ void f()
     Clock::time_point t1 = Clock::now();
     if (runs == 0)
     {
-      assert(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
       assert(test2 != 0);
     }
     else
     {
-      assert(t1 - t0 - Clock::duration(250) < max_diff);
+      ns d = t1 - t0 - Clock::duration(250);
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
       assert(test2 == 0);
     }
     ++runs;

test/sync/conditions/condition_variable/wait_until_pred_pass.cpp

@@ -23,11 +23,13 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <cassert>
 #include <iostream>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::milliseconds milliseconds;
 typedef boost::chrono::nanoseconds nanoseconds;
-
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 struct Clock
 {
   typedef boost::chrono::milliseconds duration;
@@ -66,11 +68,7 @@ int test2 = 0;
 
 int runs = 0;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const Clock::duration max_diff(250);
-#else
-const Clock::duration max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {

test/sync/conditions/condition_variable_any/lost_notif_pass.cpp

@@ -237,5 +237,5 @@ int main()
     test_chrono_wait_function(wait_for_with_pred);
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

test/sync/conditions/condition_variable_any/wait_for_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -38,12 +39,10 @@ int runs = 0;
 
 typedef boost::chrono::system_clock Clock;
 typedef boost::chrono::milliseconds milliseconds;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -57,12 +56,14 @@ void f()
     Clock::time_point t1 = Clock::now();
     if (runs == 0)
     {
-        BOOST_TEST(t1 - t0 < max_diff);
+        ns d = t1 - t0;
+        BOOST_THREAD_TEST_IT(d, ns(max_diff));
         BOOST_TEST(test2 != 0);
     }
     else
     {
-        BOOST_TEST(t1 - t0 - milliseconds(250) < max_diff);
+        ns d = t1 - t0 - ms(250);
+        BOOST_THREAD_TEST_IT(d, ns(max_diff));
         BOOST_TEST(test2 == 0);
     }
     ++runs;

test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -53,12 +54,10 @@ int runs = 0;
 
 typedef boost::chrono::system_clock Clock;
 typedef boost::chrono::milliseconds milliseconds;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -71,13 +70,15 @@ void f()
   Clock::time_point t1 = Clock::now();
   if (runs == 0)
   {
-    BOOST_TEST(t1 - t0 < max_diff);
-    BOOST_TEST(test2 != 0);
+      ns d = t1 - t0 ;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
+      BOOST_TEST(test2 != 0);
   }
   else
   {
-    BOOST_TEST(t1 - t0 - milliseconds(250) < max_diff);
-    BOOST_TEST(test2 == 0);
+      ns d = t1 - t0 - ms(250);
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
+      BOOST_TEST(test2 == 0);
   }
   ++runs;
 }

test/sync/conditions/condition_variable_any/wait_until_pass.cpp

@@ -21,9 +21,11 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
-
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 struct Clock
 {
   typedef boost::chrono::milliseconds duration;
@@ -51,11 +53,7 @@ int test2 = 0;
 
 int runs = 0;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const Clock::duration max_diff(250);
-#else
-const Clock::duration max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -69,13 +67,15 @@ void f()
   Clock::time_point t1 = Clock::now();
   if (runs == 0)
   {
-    BOOST_TEST(t1 - t0 < max_diff);
-    BOOST_TEST(test2 != 0);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
+      BOOST_TEST(test2 != 0);
   }
   else
   {
-    BOOST_TEST(t1 - t0 - Clock::duration(250) < max_diff);
-    BOOST_TEST(test2 == 0);
+      ns d = t1 - t0 - ms(250);
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
+      BOOST_TEST(test2 == 0);
   }
   ++runs;
 }

test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp

@@ -21,9 +21,13 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
+
 struct Clock
 {
   typedef boost::chrono::milliseconds duration;
@@ -66,11 +70,7 @@ int test2 = 0;
 
 int runs = 0;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const Clock::duration max_diff(250);
-#else
-const Clock::duration max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -84,13 +84,15 @@ void f()
   Clock::time_point t1 = Clock::now();
   if (runs == 0)
   {
-    BOOST_TEST(t1 - t0 < max_diff);
+    ns d = t1 - t0;
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
     BOOST_TEST(test2 != 0);
     BOOST_TEST(r);
   }
   else
   {
-    BOOST_TEST(t1 - t0 - Clock::duration(250) < max_diff);
+    ns d = t1 - t0 - ms(250);
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
     BOOST_TEST(test2 == 0);
     BOOST_TEST(!r);
   }

test/sync/futures/future/wait_for_pass.cpp

@@ -24,6 +24,7 @@
 //#define BOOST_THREAD_USES_LOG
 #define BOOST_THREAD_USES_LOG_THREAD_ID
 #include <boost/thread/detail/log.hpp>
+#include "../../../timming.hpp"
 
 #include <boost/thread/future.hpp>
 #include <boost/thread/thread.hpp>
@@ -37,6 +38,7 @@
 #endif
 
 typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 namespace boost
 {
@@ -85,11 +87,7 @@ void func5(boost::promise<void> p)
   p.set_value();
 }
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 int main()
 {
@@ -116,7 +114,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef int& T;
@@ -138,7 +137,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef void T;
@@ -160,7 +160,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;

test/sync/futures/future/wait_until_pass.cpp

@@ -30,6 +30,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/chrono/chrono_io.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -38,6 +39,7 @@
 #endif
 
 typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 namespace boost
 {
@@ -86,11 +88,7 @@ void func5(boost::promise<void> p)
   p.set_value();
 }
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 int main()
 {
@@ -117,7 +115,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef int& T;
@@ -139,7 +138,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef void T;
@@ -161,7 +161,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;

test/sync/futures/packaged_task/non_member_swap_pass.cpp

@@ -59,6 +59,7 @@ int main()
       BOOST_TEST(!p0.valid());
       BOOST_TEST(!p.valid());
   }
+  return boost::report_errors();
 
 }
 

test/sync/futures/shared_future/wait_for_pass.cpp

@@ -29,6 +29,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/chrono/chrono_io.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -37,6 +38,7 @@
 #endif
 
 typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 namespace boost
 {
@@ -85,11 +87,7 @@ void func5(boost::promise<void> p)
   p.set_value();
 }
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 int main()
 {
@@ -116,7 +114,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef int& T;
@@ -138,7 +137,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef void T;
@@ -160,7 +160,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;

test/sync/futures/shared_future/wait_until_pass.cpp

@@ -30,6 +30,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/chrono/chrono_io.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -38,6 +39,7 @@
 #endif
 
 typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 namespace boost
 {
@@ -86,11 +88,7 @@ void func5(boost::promise<void> p)
   p.set_value();
 }
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 int main()
 {
@@ -117,7 +115,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef int& T;
@@ -139,7 +138,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef void T;
@@ -161,7 +161,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;

test/sync/futures/when_any/iterators_pass.cpp

@@ -205,7 +205,6 @@ int main()
     BOOST_TEST(all.valid());
     BOOST_TEST(! all.is_ready());
     pt1();
-    BOOST_TEST(! all.is_ready());
     pt2();
     boost::this_thread::sleep_for(boost::chrono::milliseconds(300));
     BOOST_TEST(all.is_ready());

test/sync/futures/when_any/variadic_pass.cpp

@@ -169,7 +169,6 @@ int main()
     BOOST_TEST(all.valid());
     BOOST_TEST(! all.is_ready());
     pt1();
-    BOOST_TEST(! all.is_ready());
     pt2();
     boost::this_thread::sleep_for(boost::chrono::milliseconds(300));
     BOOST_TEST(all.is_ready());

test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -29,27 +30,22 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     m.lock();
     boost::lock_guard<boost::mutex> lg(m, boost::adopt_lock);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -68,11 +64,22 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -29,27 +30,22 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     boost::lock_guard<boost::mutex> lg(m);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -67,10 +63,21 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }

test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_fail.cpp

@@ -0,0 +1,21 @@
+// Copyright (C) 2018 Tom Hughes
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// <boost/thread/lock_guard.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(Mutex& m_, adopt_lock_t)
+
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+void fail()
+{
+  boost::lock_guard<boost::mutex> lk(m, boost::adopt_lock);
+}

test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_pass.cpp

@@ -0,0 +1,22 @@
+// Copyright (C) 2018 Tom Hughes
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// <boost/thread/lock_guard.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(Mutex& m_, adopt_lock_t)
+
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+void pass()
+{
+  m.lock();
+  boost::lock_guard<boost::mutex> lk(m, boost::adopt_lock);
+}

test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_fail.cpp

@@ -0,0 +1,22 @@
+// Copyright (C) 2018 Tom Hughes
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// <boost/thread/lock_guard.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(Mutex& m_)
+
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+void fail()
+{
+  boost::lock_guard<boost::mutex> lk0(m);
+  boost::lock_guard<boost::mutex> lk1(m);
+}

test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_pass.cpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2018 Tom Hughes
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// <boost/thread/lock_guard.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(Mutex& m_)
+
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+void pass()
+{
+  {
+    boost::lock_guard<boost::mutex> lk0(m);
+  }
+  boost::lock_guard<boost::mutex> lk1(m);
+}

test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_adopt_lock_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 
 #ifdef BOOST_THREAD_USES_CHRONO
@@ -31,30 +32,25 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     m.lock();
     auto&& lg = boost::make_lock_guard(m, boost::adopt_lock); (void)lg;
 
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -75,10 +71,22 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
+
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
 #endif
   return boost::report_errors();
 }

test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_pass.cpp

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -31,41 +32,45 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD && defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     const auto&& lg = boost::make_lock_guard(m); (void)lg;
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 #endif
 
 int main()
 {
 
-#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD
+#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD && defined BOOST_THREAD_USES_CHRONO
   {
     m.lock();
     boost::thread t(f);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
 #endif
   return boost::report_errors();

test/sync/mutual_exclusion/locks/nested_strict_lock/default_pass.cpp

@@ -14,6 +14,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -21,28 +22,23 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   boost::unique_lock<boost::mutex> lg(m);
   {
     boost::nested_strict_lock<boost::unique_lock<boost::mutex> > nlg(lg);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -62,10 +58,21 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
+
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
   }
 
   return boost::report_errors();

test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp

@@ -16,6 +16,7 @@
 #include <boost/thread/thread.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -23,42 +24,46 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   boost::unique_lock<boost::mutex> lg(m);
   {
     const auto&& nlg = boost::make_nested_strict_lock(lg); (void)nlg;
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 #endif
 
 int main()
 {
 
-#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK
+#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO
   {
     m.lock();
     boost::thread t(f);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
 #endif
   return boost::report_errors();

test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp

@@ -24,39 +24,36 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/chrono/chrono_io.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::shared_lock<boost::shared_mutex> lk(m, ms(750));
   BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  t1 = Clock::now();
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::shared_lock<boost::shared_mutex> lk(m, ms(250));
   BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -64,9 +61,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp

@@ -18,40 +18,35 @@
 
 // explicit shared_lock(Mutex& m);
 
-
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     boost::shared_lock<boost::shared_mutex> ul(m);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -69,12 +64,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp

@@ -23,39 +23,36 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::shared_lock<boost::shared_mutex> lk(m, Clock::now() + ms(750));
   BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  t1 = Clock::now();
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::shared_lock<boost::shared_mutex> lk(m, Clock::now() + ms(250));
   BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -63,9 +60,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp

@@ -18,33 +18,31 @@
 
 // shared_lock(mutex_type& m, try_to_lock_t);
 
-
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   {
     boost::shared_lock<boost::shared_mutex> lk(m, boost::try_to_lock);
     BOOST_TEST(lk.owns_lock() == false);
@@ -60,11 +58,11 @@ void f()
   for (;;)
   {
     boost::shared_lock<boost::shared_mutex> lk(m, boost::try_to_lock);
-    if (lk.owns_lock()) break;
+    if (lk.owns_lock()) {
+      t1 = Clock::now();
+      break;
+    }
   }
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
 //  time_point t0 = Clock::now();
 //  {
@@ -95,12 +93,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

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

@@ -23,34 +23,31 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
   boost::shared_lock < boost::shared_mutex > lk(m, boost::defer_lock);
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   lk.lock();
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
   try
   {
     lk.lock();
@@ -107,12 +104,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/locks/shared_lock_guard/adopt_lock_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -29,29 +30,24 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
 boost::shared_mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     m.lock_shared();
     boost::shared_lock_guard<boost::shared_mutex> lg(m, boost::adopt_lock);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -70,12 +66,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/locks/shared_lock_guard/default_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include  <iostream>
+#include "../../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -30,29 +31,23 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
 boost::shared_mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     boost::shared_lock_guard<boost::shared_mutex> lg(m);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
-  std::cout << "diff= " << d.count() << std::endl;
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -70,11 +65,22 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }

test/sync/mutual_exclusion/locks/strict_lock/default_pass.cpp

@@ -13,6 +13,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -20,27 +21,22 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     boost::strict_lock<boost::mutex> lg(m);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -58,10 +54,21 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }

test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp

@@ -15,6 +15,7 @@
 #include <boost/thread/thread.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -22,41 +23,47 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     const auto&& lg = boost::make_strict_lock(m); (void)lg;
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 #endif
 
 int main()
 {
 
-#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_STRICT_LOCK
+#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO
   {
     m.lock();
     boost::thread t(f);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
 #endif
   return boost::report_errors();

test/sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp

@@ -26,41 +26,38 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/chrono/chrono_io.hpp>
+#include "../../../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
 boost::timed_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::unique_lock<boost::timed_mutex> lk(m, ms(750));
   BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  t1 = Clock::now();
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::unique_lock<boost::timed_mutex> lk(m, ms(250));
   BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -68,9 +65,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_mutex_pass.cpp

@@ -15,6 +15,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 //#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
@@ -22,25 +23,22 @@ boost::mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
   auto
@@ -51,8 +49,6 @@ void f()
     _ = boost::make_unique_lock(m); (void)_;
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -76,12 +72,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 //#else

test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_try_to_lock_pass.cpp

@@ -15,29 +15,28 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
   {
-    time_point t0 = Clock::now();
+    t0 = Clock::now();
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
   auto
 #else
@@ -45,12 +44,12 @@ void f()
 #endif
     lk = boost::make_unique_lock(m, boost::try_to_lock);
     BOOST_TEST(lk.owns_lock() == false);
-    time_point t1 = Clock::now();
-    ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
+    t1 = Clock::now();
+    ns d = t1 - t0;
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
   }
   {
-    time_point t0 = Clock::now();
+    t0 = Clock::now();
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
   auto
 #else
@@ -58,12 +57,12 @@ void f()
 #endif
     lk = boost::make_unique_lock(m, boost::try_to_lock);
     BOOST_TEST(lk.owns_lock() == false);
-    time_point t1 = Clock::now();
-    ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
+    t1 = Clock::now();
+    ns d = t1 - t0;
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
   }
   {
-    time_point t0 = Clock::now();
+    t0 = Clock::now();
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
   auto
 #else
@@ -71,12 +70,12 @@ void f()
 #endif
     lk = boost::make_unique_lock(m, boost::try_to_lock);
     BOOST_TEST(lk.owns_lock() == false);
-    time_point t1 = Clock::now();
-    ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
+    t1 = Clock::now();
+    ns d = t1 - t0;
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
   }
   {
-    time_point t0 = Clock::now();
+    t0 = Clock::now();
     for (;;)
     {
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
@@ -85,11 +84,11 @@ void f()
       boost::unique_lock<boost::mutex>
 #endif
       lk = boost::make_unique_lock(m, boost::try_to_lock);
-      if (lk.owns_lock()) break;
+      if (lk.owns_lock()) {
+        t1 = Clock::now();
+        break;
+      }
     }
-    time_point t1 = Clock::now();
-    ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
   }
 #else
 //  time_point t0 = Clock::now();
@@ -126,11 +125,22 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }

test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_locks_mutex_pass.cpp

@@ -14,6 +14,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS && ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
 
@@ -24,31 +25,26 @@ boost::mutex m3;
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     auto&& _ = boost::make_unique_locks(m1,m2,m3); (void)_;
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -68,7 +64,9 @@ int main()
   m3.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m1.unlock();
@@ -76,6 +74,15 @@ int main()
   m3.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 #else

test/sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp

@@ -24,38 +24,32 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 
 boost::mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     boost::unique_lock<boost::mutex> ul(m);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -73,12 +67,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp

@@ -25,39 +25,36 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
 boost::timed_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::unique_lock<boost::timed_mutex> lk(m, Clock::now() + ms(750));
   BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  t1 = Clock::now();
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::unique_lock<boost::timed_mutex> lk(m, Clock::now() + ms(250));
   BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
   BOOST_TEST(d < max_diff);
 }
@@ -67,9 +64,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp

@@ -23,29 +23,28 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 
 boost::mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   {
     boost::unique_lock<boost::mutex> lk(m, boost::try_to_lock);
     BOOST_TEST(lk.owns_lock() == false);
@@ -61,14 +60,12 @@ void f()
   for (;;)
   {
     boost::unique_lock<boost::mutex> lk(m, boost::try_to_lock);
-    if (lk.owns_lock()) break;
+    if (lk.owns_lock()) {
+      t1 = Clock::now();
+      break;
+    }
   }
-  time_point t1 = Clock::now();
   //m.unlock();
-  ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
 #else
 //  time_point t0 = Clock::now();
 //  {
@@ -99,12 +96,25 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  std::cout << "d_ns: " << d_ns.count() << std::endl;
+  std::cout << "d_ms: " << d_ms.count() << std::endl;
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

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

@@ -23,34 +23,31 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
   boost::unique_lock < boost::mutex > lk(m, boost::defer_lock);
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   lk.lock();
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
   try
   {
     lk.lock();
@@ -107,12 +104,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp

@@ -26,39 +26,36 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/chrono/chrono_io.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::upgrade_lock<boost::shared_mutex> lk(m, ms(750));
   BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  t1 = Clock::now();
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::upgrade_lock<boost::shared_mutex> lk(m, ms(250));
   BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -66,9 +63,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp

@@ -24,37 +24,31 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     boost::upgrade_lock<boost::shared_mutex> ul(m);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -72,12 +66,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp

@@ -25,39 +25,36 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::upgrade_lock<boost::shared_mutex> lk(m, Clock::now() + ms(750));
   BOOST_TEST(lk.owns_lock() == true);
-  time_point t1 = Clock::now();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  t1 = Clock::now();
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   boost::upgrade_lock<boost::shared_mutex> lk(m, Clock::now() + ms(250));
   BOOST_TEST(lk.owns_lock() == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -65,9 +62,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp

@@ -23,28 +23,27 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   {
     boost::upgrade_lock<boost::shared_mutex> lk(m, boost::try_to_lock);
     BOOST_TEST(lk.owns_lock() == false);
@@ -60,12 +59,12 @@ void f()
   for (;;)
   {
     boost::upgrade_lock<boost::shared_mutex> lk(m, boost::try_to_lock);
-    if (lk.owns_lock()) break;
+    if (lk.owns_lock()) {
+      t1 = Clock::now();
+      break;
+    }
   }
-  time_point t1 = Clock::now();
   //m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
 //  time_point t0 = Clock::now();
 //  {
@@ -96,12 +95,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

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

@@ -23,34 +23,31 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
   boost::upgrade_lock < boost::shared_mutex > lk(m, boost::defer_lock);
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   lk.lock();
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
   try
   {
     lk.lock();
@@ -107,12 +104,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/mutex/lock_compile_fail.cpp

@@ -0,0 +1,19 @@
+// Copyright (C) 2017 Tom Hughes
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// <boost/thread/mutex.hpp>
+
+// class mutex;
+
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+void fail()
+{
+  boost::mutex m0;
+  m0.lock();
+  m0.lock();
+  m0.unlock();
+}

test/sync/mutual_exclusion/mutex/lock_compile_pass.cpp

@@ -0,0 +1,18 @@
+// Copyright (C) 2017 Tom Hughes
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// <boost/thread/mutex.hpp>
+
+// class mutex;
+
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+void pass()
+{
+  boost::mutex m0;
+  m0.lock();
+  m0.unlock();
+}

test/sync/mutual_exclusion/mutex/lock_pass.cpp

@@ -21,34 +21,30 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-
+#include "../../../timming.hpp"
 
 boost::mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   m.lock();
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   m.lock();
@@ -64,11 +60,22 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/mutex/try_lock_compile_fail.cpp

@@ -0,0 +1,19 @@
+// Copyright (C) 2017 Tom Hughes
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// <boost/thread/mutex.hpp>
+
+// class mutex;
+
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+void fail()
+{
+  boost::mutex m0;
+  if (!m0.try_lock()) {
+    m0.unlock();
+  }
+}

test/sync/mutual_exclusion/mutex/try_lock_compile_pass.cpp

@@ -0,0 +1,19 @@
+// Copyright (C) 2017 Tom Hughes
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// <boost/thread/mutex.hpp>
+
+// class mutex;
+
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+void pass()
+{
+  boost::mutex m0;
+  if (m0.try_lock()) {
+    m0.unlock();
+  }
+}

test/sync/mutual_exclusion/mutex/try_lock_pass.cpp

@@ -21,37 +21,34 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 boost::mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(!m.try_lock());
   BOOST_TEST(!m.try_lock());
   BOOST_TEST(!m.try_lock());
   while (!m.try_lock())
     ;
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());
@@ -72,11 +69,22 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/null_mutex/lock_pass.cpp

@@ -21,13 +21,12 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-
-
+#include "../../../timming.hpp"
 
 boost::null_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
@@ -35,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(50);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +46,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 ;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   m.lock();

test/sync/mutual_exclusion/null_mutex/try_lock_for_pass.cpp

@@ -22,23 +22,20 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
 
 boost::null_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(50);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -49,10 +46,9 @@ void f1()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 ;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
-
 int main()
 {
   {

test/sync/mutual_exclusion/null_mutex/try_lock_pass.cpp

@@ -21,13 +21,14 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 
 boost::null_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
@@ -35,11 +36,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(50);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +48,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   BOOST_TEST(m.try_lock());
   BOOST_TEST(m.try_lock());

test/sync/mutual_exclusion/null_mutex/try_lock_until_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -33,11 +34,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(50);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -46,7 +43,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 ;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 

test/sync/mutual_exclusion/recursive_mutex/lock_pass.cpp

@@ -21,36 +21,33 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 boost::recursive_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   m.lock();
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.lock();
   m.unlock();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   m.lock();
@@ -68,12 +65,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp

@@ -22,41 +22,36 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../timming.hpp"
 
 boost::recursive_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
 //  BOOST_TEST(!m.try_lock());
 //  BOOST_TEST(!m.try_lock());
 //  BOOST_TEST(!m.try_lock());
   while (!m.try_lock())
     ;
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   BOOST_TEST(m.try_lock());
   m.unlock();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());
@@ -78,12 +73,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp

@@ -22,37 +22,32 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../timming.hpp"
 
 boost::recursive_timed_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   m.lock();
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.lock();
   m.unlock();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   m.lock();
@@ -70,12 +65,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp

@@ -22,34 +22,30 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-
 boost::recursive_timed_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_for(ms(750)) == true);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   BOOST_TEST(m.try_lock());
   m.unlock();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 
 void f2()
@@ -58,7 +54,7 @@ void f2()
   BOOST_TEST(m.try_lock_for(ms(250)) == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -66,9 +62,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp

@@ -21,41 +21,36 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-
-
+#include "../../../timming.hpp"
 
 boost::recursive_timed_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(!m.try_lock());
   BOOST_TEST(!m.try_lock());
   BOOST_TEST(!m.try_lock());
   while (!m.try_lock())
     ;
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   BOOST_TEST(m.try_lock());
   m.unlock();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());
@@ -77,12 +72,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp

@@ -22,40 +22,37 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
 boost::recursive_timed_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(750)) == true);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -63,9 +60,20 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+#if defined BOOST_THREAD_USES_CHRONO
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
   }
   {
     m.lock();

test/sync/mutual_exclusion/shared_mutex/lock_pass.cpp

@@ -21,33 +21,30 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   m.lock();
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   m.lock();
@@ -63,12 +60,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp

@@ -22,38 +22,35 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_for(ms(750)) == true);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_for(ms(250)) == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -61,9 +58,20 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+#if defined BOOST_THREAD_USES_CHRONO
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
   }
   {
     m.lock();

test/sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp

@@ -21,37 +21,34 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(!m.try_lock());
   BOOST_TEST(!m.try_lock());
   BOOST_TEST(!m.try_lock());
   while (!m.try_lock())
     ;
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());
@@ -71,12 +68,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp

@@ -22,38 +22,35 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(750)) == true);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -61,9 +58,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/sync_pq/pq_single_thread_pass.cpp

@@ -20,8 +20,11 @@
 #include <boost/thread/concurrent_queues/sync_priority_queue.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 using namespace boost::chrono;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 typedef boost::concurrent::sync_priority_queue<int> sync_pq;
 
@@ -46,11 +49,7 @@ public:
   }
 };
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void test_pull_for()
 {
@@ -58,10 +57,9 @@ void test_pull_for()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.pull_for(milliseconds(500), val);
-  steady_clock::duration diff = steady_clock::now() - start - milliseconds(500);
+  ns d = steady_clock::now() - start - milliseconds(500);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::timeout == st);
-  BOOST_TEST(diff < max_diff);
-  std::cout << "diff= " << diff.count();
 }
 
 void test_pull_until()
@@ -70,9 +68,9 @@ void test_pull_until()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.pull_until(start + milliseconds(500), val);
-  steady_clock::duration diff = steady_clock::now() - start - milliseconds(500);
+  ns d = steady_clock::now() - start - milliseconds(500);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::timeout == st);
-  BOOST_TEST(diff < max_diff);
 }
 
 void test_nonblocking_pull()
@@ -81,9 +79,9 @@ void test_nonblocking_pull()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.nonblocking_pull(val);
-  steady_clock::duration diff = steady_clock::now() - start;
+  ns d = steady_clock::now() - start;
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::empty == st);
-  BOOST_TEST(diff < max_diff);
 }
 
 void test_pull_for_when_not_empty()
@@ -93,10 +91,10 @@ void test_pull_for_when_not_empty()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.pull_for(milliseconds(500), val);
-  steady_clock::duration diff = steady_clock::now() - start;
+  ns d = steady_clock::now() - start;
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::success == st);
   BOOST_TEST(1 == val);
-  BOOST_TEST(diff < max_diff);
 }
 
 void test_pull_until_when_not_empty()
@@ -106,10 +104,10 @@ void test_pull_until_when_not_empty()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.pull_until(start + milliseconds(500), val);
-  steady_clock::duration diff = steady_clock::now() - start;
+  ns d = steady_clock::now() - start;
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::success == st);
   BOOST_TEST(1 == val);
-  BOOST_TEST(diff < max_diff);
 }
 
 int main()

test/sync/mutual_exclusion/timed_mutex/lock_pass.cpp

@@ -21,33 +21,30 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::timed_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   m.lock();
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   m.lock();
@@ -63,12 +60,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp

@@ -22,40 +22,37 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
 boost::timed_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_for(ms(750)) == true);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_for(ms(250)) == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -63,9 +60,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();

test/sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp

@@ -21,38 +21,35 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 boost::timed_mutex m;
 
 #if defined BOOST_THREAD_USES_CHRONO
-typedef boost::chrono::system_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #if defined BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(!m.try_lock());
   BOOST_TEST(!m.try_lock());
   BOOST_TEST(!m.try_lock());
   while (!m.try_lock())
     ;
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());
@@ -72,12 +69,23 @@ int main()
   m.lock();
   boost::thread t(f);
 #if defined BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #else
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp

@@ -22,40 +22,37 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
 boost::timed_mutex m;
 
-typedef boost::chrono::steady_clock Clock;
+typedef boost::chrono::high_resolution_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(750)) == true);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   m.unlock();
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 
 void f2()
 {
-  time_point t0 = Clock::now();
+  t0 = Clock::now();
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false);
-  time_point t1 = Clock::now();
+  t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()
@@ -63,9 +60,18 @@ int main()
   {
     m.lock();
     boost::thread t(f1);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
   {
     m.lock();