Merge branch 'develop'

Windows.h > windows.h

circle.yml

@@ -0,0 +1,184 @@
+# 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 -j10 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"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-g++-7-c++98:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++98"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-g++-7-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++11"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-g++-7-c++14:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++14"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-g++-7-c++1z:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++1z"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-clang++-4.0-c++98:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++98"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-clang++-4.0-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++11"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-clang++-4.0-c++14:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++14"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-clang++-4.0-c++1z:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++1z"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  mac-clang++-c++98:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++98"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=170"
+
+  mac-clang++-c++11:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++11"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=170"
+
+  mac-clang++-c++14:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++14"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=170"
+
+  mac-clang++-c++1z:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++1z"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=170"
+
+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/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

@@ -417,6 +417,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/thread.hpp

@@ -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/future.hpp

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

include/boost/thread/pthread/thread_data.hpp

@@ -130,9 +130,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 +149,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 +168,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_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

src/future.cpp

@@ -4,7 +4,14 @@
 // 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
+
+#ifdef BOOST_NO_EXCEPTIONS
+namespace boost
+{
+    void shared_state_base::notify_deferred() {}
+}
+
+#else
 
 
 #include <boost/thread/futures/future_error_code.hpp>

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()
             {}
@@ -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()

test/Jamfile.v2

@@ -970,7 +970,8 @@ 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 ]
           
     ;
 

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()
 {

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/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/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/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;
@@ -32,11 +33,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -49,7 +46,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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;
@@ -33,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 
 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()
 {
@@ -49,7 +46,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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
@@ -36,11 +37,7 @@ 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()
 {
@@ -54,7 +51,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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;
@@ -37,11 +38,7 @@ 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()
 {
@@ -52,7 +49,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 #endif
 

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;
@@ -25,11 +26,7 @@ typedef boost::chrono::nanoseconds ns;
 
 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()
 {
@@ -42,7 +39,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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;
@@ -29,11 +30,7 @@ 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()
 {
@@ -45,7 +42,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 #endif
 

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

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/chrono/chrono_io.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -46,7 +43,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -56,7 +53,7 @@ void f2()
   BOOST_TEST(lk.owns_lock() == 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()

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

@@ -18,11 +18,11 @@
 
 // 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;
 
@@ -35,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -51,7 +47,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -23,6 +23,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -32,11 +33,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -45,7 +42,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -55,7 +52,7 @@ void f2()
   BOOST_TEST(lk.owns_lock() == 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()

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

@@ -18,11 +18,11 @@
 
 // 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;
 
@@ -35,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -64,7 +60,7 @@ void f()
   }
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
 //  time_point t0 = Clock::now();
 //  {

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

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -50,7 +47,7 @@ void f()
   time_point t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   try
   {
     lk.lock();

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;
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 
 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()
 {
@@ -51,7 +48,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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;
@@ -35,11 +36,7 @@ typedef boost::chrono::nanoseconds ns;
 
 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()
 {
@@ -51,8 +48,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
-  std::cout << "diff= " << d.count() << std::endl;
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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;
@@ -24,11 +25,7 @@ typedef boost::chrono::nanoseconds ns;
 
 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()
 {
@@ -40,7 +37,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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;
@@ -28,11 +29,7 @@ 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()
 {
@@ -43,7 +40,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 #endif
 

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

@@ -26,6 +26,7 @@
 #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
 
@@ -37,11 +38,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -50,7 +47,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()

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)
 
@@ -30,11 +31,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -52,7 +49,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_try_to_lock_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"
 
 boost::mutex m;
 
@@ -27,11 +28,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -47,7 +44,7 @@ void f()
     BOOST_TEST(lk.owns_lock() == 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));
   }
   {
     time_point t0 = Clock::now();
@@ -60,7 +57,7 @@ void f()
     BOOST_TEST(lk.owns_lock() == 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));
   }
   {
     time_point t0 = Clock::now();
@@ -73,7 +70,7 @@ void f()
     BOOST_TEST(lk.owns_lock() == 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));
   }
   {
     time_point t0 = Clock::now();
@@ -89,7 +86,7 @@ void f()
     }
     time_point t1 = Clock::now();
     ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
   }
 #else
 //  time_point t0 = Clock::now();

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
 
@@ -32,11 +33,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -48,7 +45,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 
 boost::mutex m;
@@ -37,11 +38,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -53,9 +50,7 @@ void f()
     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);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -25,6 +25,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
 
@@ -36,11 +37,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -49,7 +46,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()

test/sync/mutual_exclusion/locks/unique_lock/cons/try_to_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"
 
 
 boost::mutex m;
@@ -36,11 +37,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -66,9 +63,7 @@ void f()
   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);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
 //  time_point t0 = Clock::now();
 //  {

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

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::mutex m;
 
@@ -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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -50,7 +47,7 @@ void f()
   time_point t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   try
   {
     lk.lock();

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

@@ -26,6 +26,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/chrono/chrono_io.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -35,11 +36,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -48,7 +45,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -58,7 +55,7 @@ void f2()
   BOOST_TEST(lk.owns_lock() == 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()

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

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -36,11 +37,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -54,7 +51,7 @@ void f()
   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);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -25,6 +25,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -34,11 +35,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -47,7 +44,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -57,7 +54,7 @@ void f2()
   BOOST_TEST(lk.owns_lock() == 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()

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

@@ -23,6 +23,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -65,7 +62,7 @@ void f()
   time_point t1 = Clock::now();
   //m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
 //  time_point t0 = Clock::now();
 //  {

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

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -50,7 +47,7 @@ void f()
   time_point t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   try
   {
     lk.lock();

test/sync/mutual_exclusion/mutex/lock_pass.cpp

@@ -21,7 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-
+#include "../../../timming.hpp"
 
 boost::mutex m;
 
@@ -34,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -48,7 +44,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  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/mutex/try_lock_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"
 
 
 boost::mutex m;
@@ -33,11 +34,7 @@ typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -51,7 +48,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/null_mutex/lock_pass.cpp

@@ -21,8 +21,7 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-
-
+#include "../../../timming.hpp"
 
 boost::null_mutex m;
 
@@ -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,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
 
@@ -34,11 +35,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()
 {
@@ -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,6 +21,7 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 
@@ -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,6 +21,7 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 boost::recursive_mutex m;
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -50,7 +47,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  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/recursive_mutex/try_lock_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../timming.hpp"
 
 boost::recursive_mutex m;
 
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -54,9 +51,7 @@ void f()
   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);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../timming.hpp"
 
 boost::recursive_timed_mutex m;
 
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -50,9 +47,7 @@ void f()
   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);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   m.lock();

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp

@@ -22,10 +22,10 @@
 #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;
@@ -34,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -49,7 +45,7 @@ void f1()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(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()

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp

@@ -21,8 +21,7 @@
 #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;
 
@@ -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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -55,7 +50,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp

@@ -22,6 +22,7 @@
 #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
 
@@ -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(75);
-#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 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -55,7 +52,7 @@ void f2()
   BOOST_TEST(m.try_lock_until(Clock::now() + 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()

test/sync/mutual_exclusion/shared_mutex/lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -33,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -47,7 +44,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  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/shared_mutex/try_lock_for_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"
 
 boost::shared_mutex m;
 
@@ -31,11 +32,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -44,7 +41,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -53,7 +50,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()

test/sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -33,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +48,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/shared_mutex/try_lock_until_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"
 
 boost::shared_mutex m;
 
@@ -31,11 +32,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -44,7 +41,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -53,7 +50,7 @@ void f2()
   BOOST_TEST(m.try_lock_until(Clock::now() + 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()

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,6 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::timed_mutex m;
 
@@ -33,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(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -47,7 +44,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  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/timed_mutex/try_lock_for_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"
 
 #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(75);
-#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 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -55,7 +52,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()

test/sync/mutual_exclusion/timed_mutex/try_lock_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"
 
 
 boost::timed_mutex m;
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #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()
 {
@@ -52,7 +49,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/timed_mutex/try_lock_until_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"
 
 #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(75);
-#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 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -55,7 +52,7 @@ void f2()
   BOOST_TEST(m.try_lock_until(Clock::now() + 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()

test/test_13480b.cpp

@@ -0,0 +1,77 @@
+// comment if you want to see the boost::move issue
+#define BOOST_THREAD_VERSION 3
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/variant/detail/apply_visitor_binary.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+
+#define WANT_BUILD_TO_FAIL
+#ifdef WANT_BUILD_TO_FAIL
+#include <boost/thread.hpp>
+#endif
+
+class AType
+{
+
+};
+
+class BType
+{
+};
+
+typedef boost::shared_ptr<AType> IATypePtr;
+typedef boost::shared_ptr<BType> IBTypePtr;
+
+typedef boost::variant<IATypePtr, IBTypePtr> ABVar;
+
+struct ServiceTimeTableEvent
+{
+public:
+
+    ServiceTimeTableEvent(ABVar abType)
+        : m_abType{ abType }
+        {}
+
+        inline ABVar const& GetABType() const { return m_abType; }
+        inline ABVar & GetABType() { return m_abType; }
+
+private:
+    ABVar           m_abType;
+};
+
+class ab_are_equals
+    : public boost::static_visitor<bool>
+{
+public:
+    template<typename T, typename U>
+    bool operator()(T, U) const
+    {
+        return false; // cannot compare different types
+    }
+    template<typename T>
+    bool operator()(T lhs, T rhs) const
+    {
+        return  lhs == rhs;
+    }
+};
+
+int main(int argc, char* argv[])
+{
+
+    auto aTypePtr = IATypePtr{ new AType };
+    auto bTypePtr = IBTypePtr{ new BType };
+
+    ABVar aType = aTypePtr;
+    ABVar bType = bTypePtr;
+
+    ServiceTimeTableEvent timeTableEvent1{ aType };
+    ServiceTimeTableEvent timeTableEvent2{ bType };
+
+    auto xx = boost::apply_visitor(ab_are_equals(), timeTableEvent1.GetABType(), timeTableEvent2.GetABType());
+    xx = boost::apply_visitor(ab_are_equals(), timeTableEvent1.GetABType(), timeTableEvent1.GetABType());;
+    xx = boost::apply_visitor(ab_are_equals(), timeTableEvent2.GetABType(), timeTableEvent2.GetABType());;
+}
+
+

test/test_shared_mutex_timed_locks_chrono.cpp

@@ -65,7 +65,6 @@ BOOST_AUTO_TEST_CASE(test_timed_lock_shared_succeeds_if_no_lock_held)
 
     boost::chrono::steady_clock::time_point const start=boost::chrono::steady_clock::now();
     boost::chrono::steady_clock::time_point const timeout=start+boost::chrono::milliseconds(500);
-    boost::chrono::milliseconds const timeout_resolution(50);
     bool timed_lock_succeeded=rw_mutex.try_lock_shared_until(timeout);
     BOOST_CHECK(boost::chrono::steady_clock::now()<timeout);
     BOOST_CHECK(timed_lock_succeeded);
@@ -99,7 +98,6 @@ BOOST_AUTO_TEST_CASE(test_timed_lock_shared_succeeds_if_read_lock_held)
 
     boost::chrono::steady_clock::time_point const start=boost::chrono::steady_clock::now();
     boost::chrono::steady_clock::time_point const timeout=start+boost::chrono::milliseconds(500);
-    boost::chrono::milliseconds const timeout_resolution(50);
     bool timed_lock_succeeded=rw_mutex.try_lock_shared_until(timeout);
     BOOST_CHECK(boost::chrono::steady_clock::now()<timeout);
     BOOST_CHECK(timed_lock_succeeded);
@@ -166,7 +164,6 @@ BOOST_AUTO_TEST_CASE(test_timed_lock_succeeds_if_no_lock_held)
 
     boost::chrono::steady_clock::time_point const start=boost::chrono::steady_clock::now();
     boost::chrono::steady_clock::time_point const timeout=start+boost::chrono::milliseconds(500);
-    boost::chrono::milliseconds const timeout_resolution(50);
     bool timed_lock_succeeded=rw_mutex.try_lock_until(timeout);
     BOOST_CHECK(boost::chrono::steady_clock::now()<timeout);
     BOOST_CHECK(timed_lock_succeeded);

test/test_time_jumps.cpp

@@ -1,5 +1,5 @@
 #ifdef _WIN32
-	#include <Windows.h>
+	#include <windows.h>
 #else
 	#include <sys/time.h>
 #endif

test/timming.hpp

@@ -0,0 +1,26 @@
+// Copyright (C) 2018 Vicente Botet
+//
+//  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)
+
+#ifndef BOOST_THREAD_TEST_TIMMING_HPP
+#define BOOST_THREAD_TEST_TIMMING_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if ! defined BOOST_THREAD_TEST_TIME_MS
+#ifdef BOOST_THREAD_PLATFORM_WIN32
+#define BOOST_THREAD_TEST_TIME_MS 250
+#else
+#define BOOST_THREAD_TEST_TIME_MS 75
+#endif
+#endif
+
+#if ! defined BOOST_THREAD_TEST_TIME_WARNING
+#define BOOST_THREAD_TEST_IT(A, B) BOOST_TEST_LT((A).count(), (B).count())
+#else
+#define BOOST_THREAD_TEST_IT(A, B) BOOST_TEST_LT((A).count(), (B).count())
+#endif
+
+#endif