[Boost-commit] svn:boost r85794 - in trunk: boost/sync/detail boost/sync/mutexes boost/sync/support libs/sync/test libs/sync/test/run

Subject: [Boost-commit] svn:boost r85794 - in trunk: boost/sync/detail boost/sync/mutexes boost/sync/support libs/sync/test libs/sync/test/run
From: andrey.semashev_at_[hidden]
Date: 2013-09-19 16:27:08

Author: andysem
Date: 2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)
New Revision: 85794
URL: http://svn.boost.org/trac/boost/changeset/85794

Log:
Bug fixes. Preliminary test for mutex added.

Added:
   trunk/libs/sync/test/run/
   trunk/libs/sync/test/run/event_test.cpp
      - copied unchanged from r85792, trunk/libs/sync/test/event_test.cpp
   trunk/libs/sync/test/run/mutex_test.cpp   (contents, props changed)
   trunk/libs/sync/test/run/semaphore_test.cpp
      - copied unchanged from r85792, trunk/libs/sync/test/semaphore_test.cpp
   trunk/libs/sync/test/run/utils.hpp   (contents, props changed)
Deleted:
   trunk/libs/sync/test/event_test.cpp
   trunk/libs/sync/test/semaphore_test.cpp
Text files modified: 
   trunk/boost/sync/detail/interlocked.hpp     |    10                                         
   trunk/boost/sync/mutexes/timed_mutex.hpp    |     2                                         
   trunk/boost/sync/support/date_time.hpp      |     4                                         
   trunk/libs/sync/test/Jamfile.v2             |     3                                         
   /dev/null                                   |   144 -----------------                       
   trunk/libs/sync/test/run/event_test.cpp     |   144 +++++++++++++++++                       
   trunk/libs/sync/test/run/mutex_test.cpp     |   330 ++++++++++++++++++++++++++++++++++++++++
   trunk/libs/sync/test/run/semaphore_test.cpp |   113 +++++++++++++                           
   trunk/libs/sync/test/run/utils.hpp          |   223 +++++++++++++++++++++++++++             
   /dev/null                                   |   113 -------------                           
   10 files changed, 821 insertions(+), 265 deletions(-)

Modified: trunk/boost/sync/detail/interlocked.hpp
==============================================================================
--- trunk/boost/sync/detail/interlocked.hpp	Thu Sep 19 16:04:47 2013	(r85793)
+++ trunk/boost/sync/detail/interlocked.hpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85794)
@@ -144,7 +144,7 @@
 #undef BOOST_SYNC_DETAIL_BTS_DEFINED
 
 #if defined(__INTEL_COMPILER)
-#define BOOST_SYNC_COMPILER_BARRIER __memory_barrier();
+#define BOOST_SYNC_COMPILER_BARRIER() __memory_barrier()
 #elif defined(_MSC_VER) && _MSC_VER >= 1310 && !defined(_WIN32_WCE)
 extern "C" void _ReadWriteBarrier(void);
 #pragma intrinsic(_ReadWriteBarrier)
@@ -156,24 +156,24 @@
 BOOST_FORCEINLINE long interlocked_read_acquire(long volatile* x) BOOST_NOEXCEPT
 {
     long const res = *x;
-    BOOST_SYNC_COMPILER_BARRIER;
+    BOOST_SYNC_COMPILER_BARRIER();
     return res;
 }
 BOOST_FORCEINLINE void* interlocked_read_acquire(void* volatile* x) BOOST_NOEXCEPT
 {
     void* const res = *x;
-    BOOST_SYNC_COMPILER_BARRIER;
+    BOOST_SYNC_COMPILER_BARRIER();
     return res;
 }
 
 BOOST_FORCEINLINE void interlocked_write_release(long volatile* x, long value) BOOST_NOEXCEPT
 {
-    BOOST_SYNC_COMPILER_BARRIER;
+    BOOST_SYNC_COMPILER_BARRIER();
     *x = value;
 }
 BOOST_FORCEINLINE void interlocked_write_release(void* volatile* x, void* value) BOOST_NOEXCEPT
 {
-    BOOST_SYNC_COMPILER_BARRIER;
+    BOOST_SYNC_COMPILER_BARRIER();
     *x = value;
 }
 

Modified: trunk/boost/sync/mutexes/timed_mutex.hpp
==============================================================================
--- trunk/boost/sync/mutexes/timed_mutex.hpp	Thu Sep 19 16:04:47 2013	(r85793)
+++ trunk/boost/sync/mutexes/timed_mutex.hpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85794)
@@ -115,7 +115,7 @@
 #if defined(BOOST_SYNC_DETAIL_PLATFORM_PTHREAD)
 #include <boost/sync/detail/mutexes/timed_mutex_posix.hpp>
 #elif defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)
-#include <boost/sync/detail/mutexes/timed_mutex_windows.hpp>
+//#include <boost/sync/detail/mutexes/timed_mutex_windows.hpp>
 #else
 #error Boost.Sync: Unsupported threading API
 #endif

Modified: trunk/boost/sync/support/date_time.hpp
==============================================================================
--- trunk/boost/sync/support/date_time.hpp	Thu Sep 19 16:04:47 2013	(r85793)
+++ trunk/boost/sync/support/date_time.hpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85794)
@@ -34,7 +34,7 @@
 template< typename T >
 struct time_traits< T, typename T::_is_boost_date_time_duration >
 {
-    typedef duration_tag tag;
+    typedef time_duration_tag tag;
 
     static BOOST_CONSTEXPR_OR_CONST bool is_specialized = true;
 
@@ -80,6 +80,8 @@
 
 } // namespace detail
 
+} // namespace sync
+
 } // namespace boost
 
 #include <boost/sync/detail/footer.hpp>

Modified: trunk/libs/sync/test/Jamfile.v2
==============================================================================
--- trunk/libs/sync/test/Jamfile.v2	Thu Sep 19 16:04:47 2013	(r85793)
+++ trunk/libs/sync/test/Jamfile.v2	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85794)
@@ -21,9 +21,10 @@
 {
    local all_rules = ;
 
-   for local fileb in [ glob *.cpp ]
+   for local fileb in [ glob run/*.cpp ]
    {
       local test_id = [ MATCH "(.+)\.cpp" : [ path.basename $(fileb) ] ] ;
+      # ECHO $(test_id) ;
 
       all_rules += [ run $(fileb)
       : # additional args

Deleted: trunk/libs/sync/test/event_test.cpp
==============================================================================
--- trunk/libs/sync/test/event_test.cpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85793)
+++ /dev/null	00:00:00 1970	(deleted)
@@ -1,144 +0,0 @@
-// Copyright (C) 2013 Tim Blechmann
-//
-//  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)
-
-#include <boost/test/unit_test.hpp>
-
-#include <boost/thread.hpp>
-#include <boost/sync/event.hpp>
-
-#include <boost/typeof/typeof.hpp>
-
-BOOST_AUTO_TEST_CASE(test_event_post_wait)
-{
-    boost::sync::event ev;
-
-    ev.post();
-    ev.wait();
-
-    BOOST_REQUIRE( ev.try_wait() == true );
-
-    ev.reset();
-
-    BOOST_REQUIRE( ev.try_wait() == false );
-}
-
-
-BOOST_AUTO_TEST_CASE(test_event_post_try_wait)
-{
-    boost::sync::event ev;
-
-    BOOST_REQUIRE( ev.try_wait() == false );
-
-    ev.post();
-
-    BOOST_REQUIRE( ev.try_wait() == true );
-}
-
-BOOST_AUTO_TEST_CASE(test_event_post_wait_autoreset)
-{
-    boost::sync::event ev(true);
-
-    ev.post();
-    BOOST_REQUIRE( ev.try_wait() == true );
-    BOOST_REQUIRE( ev.try_wait() == false );
-}
-
-
-BOOST_AUTO_TEST_CASE(test_event_reset)
-{
-    boost::sync::event ev(false);
-
-    BOOST_REQUIRE( ev.try_wait() == false );
-    ev.post();
-    BOOST_REQUIRE( ev.try_wait() == true );
-    ev.reset();
-    BOOST_REQUIRE( ev.try_wait() == false );
-}
-
-struct event_wait_and_post_test
-{
-    void run()
-    {
-        boost::thread post_thread(boost::bind(&event_wait_and_post_test::wait_and_post, this));
-        ev_.wait();
-    }
-
-    void wait_and_post()
-    {
-        boost::this_thread::sleep_for(boost::chrono::seconds(1));
-        ev_.post();
-    }
-
-    boost::sync::event ev_;
-    boost::thread thread_;
-};
-
-BOOST_AUTO_TEST_CASE(event_wait_and_post)
-{
-    event_wait_and_post_test test;
-    test.run();
-}
-
-
-BOOST_AUTO_TEST_CASE(test_event_wait_for)
-{
-    using namespace boost;
-
-    sync::event ev;
-
-    BOOST_AUTO(start, chrono::system_clock::now());
-
-    BOOST_REQUIRE( ev.try_wait() == false );
-
-    BOOST_REQUIRE(!ev.try_wait_for(chrono::milliseconds(500)));
-
-    BOOST_REQUIRE( ev.try_wait() == false );
-
-
-    BOOST_AUTO(end, chrono::system_clock::now());
-    BOOST_AUTO(wait_time, end - start);
-
-    // guessing!
-    BOOST_REQUIRE( wait_time > chrono::milliseconds(450) );
-    BOOST_REQUIRE( wait_time < chrono::milliseconds(1000) );
-
-    ev.post();
-
-    BOOST_REQUIRE(ev.try_wait_for(chrono::milliseconds(500)));
-}
-
-BOOST_AUTO_TEST_CASE(test_event_wait_until)
-{
-    using namespace boost;
-
-    sync::event ev(0);
-    {
-        BOOST_AUTO(now, chrono::system_clock::now());
-        BOOST_AUTO(timeout, now + chrono::milliseconds(500));
-
-        BOOST_REQUIRE(!ev.try_wait_until(timeout));
-
-        BOOST_AUTO(end, chrono::system_clock::now());
-        BOOST_AUTO(timeout_delta, end - timeout);
-
-        // guessing!
-        BOOST_REQUIRE( timeout_delta > chrono::milliseconds(-400) );
-        BOOST_REQUIRE( timeout_delta < chrono::milliseconds(400) );
-    }
-
-    ev.post();
-
-    {
-        BOOST_AUTO(start,   chrono::system_clock::now());
-        BOOST_AUTO(timeout, start + chrono::milliseconds(500));
-
-        BOOST_REQUIRE(ev.try_wait_until(timeout));
-
-        BOOST_AUTO(end, chrono::system_clock::now());
-
-        // guessing!
-        BOOST_REQUIRE( (end - start) < chrono::milliseconds(100) );
-    }
-}

Copied: trunk/libs/sync/test/run/event_test.cpp (from r85792, trunk/libs/sync/test/event_test.cpp)
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/test/run/event_test.cpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85794, copy of r85792, trunk/libs/sync/test/event_test.cpp)
@@ -0,0 +1,144 @@
+// Copyright (C) 2013 Tim Blechmann
+//
+//  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)
+
+#include <boost/test/unit_test.hpp>
+
+#include <boost/thread.hpp>
+#include <boost/sync/event.hpp>
+
+#include <boost/typeof/typeof.hpp>
+
+BOOST_AUTO_TEST_CASE(test_event_post_wait)
+{
+    boost::sync::event ev;
+
+    ev.post();
+    ev.wait();
+
+    BOOST_REQUIRE( ev.try_wait() == true );
+
+    ev.reset();
+
+    BOOST_REQUIRE( ev.try_wait() == false );
+}
+
+
+BOOST_AUTO_TEST_CASE(test_event_post_try_wait)
+{
+    boost::sync::event ev;
+
+    BOOST_REQUIRE( ev.try_wait() == false );
+
+    ev.post();
+
+    BOOST_REQUIRE( ev.try_wait() == true );
+}
+
+BOOST_AUTO_TEST_CASE(test_event_post_wait_autoreset)
+{
+    boost::sync::event ev(true);
+
+    ev.post();
+    BOOST_REQUIRE( ev.try_wait() == true );
+    BOOST_REQUIRE( ev.try_wait() == false );
+}
+
+
+BOOST_AUTO_TEST_CASE(test_event_reset)
+{
+    boost::sync::event ev(false);
+
+    BOOST_REQUIRE( ev.try_wait() == false );
+    ev.post();
+    BOOST_REQUIRE( ev.try_wait() == true );
+    ev.reset();
+    BOOST_REQUIRE( ev.try_wait() == false );
+}
+
+struct event_wait_and_post_test
+{
+    void run()
+    {
+        boost::thread post_thread(boost::bind(&event_wait_and_post_test::wait_and_post, this));
+        ev_.wait();
+    }
+
+    void wait_and_post()
+    {
+        boost::this_thread::sleep_for(boost::chrono::seconds(1));
+        ev_.post();
+    }
+
+    boost::sync::event ev_;
+    boost::thread thread_;
+};
+
+BOOST_AUTO_TEST_CASE(event_wait_and_post)
+{
+    event_wait_and_post_test test;
+    test.run();
+}
+
+
+BOOST_AUTO_TEST_CASE(test_event_wait_for)
+{
+    using namespace boost;
+
+    sync::event ev;
+
+    BOOST_AUTO(start, chrono::system_clock::now());
+
+    BOOST_REQUIRE( ev.try_wait() == false );
+
+    BOOST_REQUIRE(!ev.try_wait_for(chrono::milliseconds(500)));
+
+    BOOST_REQUIRE( ev.try_wait() == false );
+
+
+    BOOST_AUTO(end, chrono::system_clock::now());
+    BOOST_AUTO(wait_time, end - start);
+
+    // guessing!
+    BOOST_REQUIRE( wait_time > chrono::milliseconds(450) );
+    BOOST_REQUIRE( wait_time < chrono::milliseconds(1000) );
+
+    ev.post();
+
+    BOOST_REQUIRE(ev.try_wait_for(chrono::milliseconds(500)));
+}
+
+BOOST_AUTO_TEST_CASE(test_event_wait_until)
+{
+    using namespace boost;
+
+    sync::event ev(0);
+    {
+        BOOST_AUTO(now, chrono::system_clock::now());
+        BOOST_AUTO(timeout, now + chrono::milliseconds(500));
+
+        BOOST_REQUIRE(!ev.try_wait_until(timeout));
+
+        BOOST_AUTO(end, chrono::system_clock::now());
+        BOOST_AUTO(timeout_delta, end - timeout);
+
+        // guessing!
+        BOOST_REQUIRE( timeout_delta > chrono::milliseconds(-400) );
+        BOOST_REQUIRE( timeout_delta < chrono::milliseconds(400) );
+    }
+
+    ev.post();
+
+    {
+        BOOST_AUTO(start,   chrono::system_clock::now());
+        BOOST_AUTO(timeout, start + chrono::milliseconds(500));
+
+        BOOST_REQUIRE(ev.try_wait_until(timeout));
+
+        BOOST_AUTO(end, chrono::system_clock::now());
+
+        // guessing!
+        BOOST_REQUIRE( (end - start) < chrono::milliseconds(100) );
+    }
+}

Added: trunk/libs/sync/test/run/mutex_test.cpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/test/run/mutex_test.cpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85794)
@@ -0,0 +1,330 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+//  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)
+
+#include <boost/test/unit_test.hpp>
+
+#include <boost/sync/mutexes.hpp>
+#include <boost/sync/locks.hpp>
+#include <boost/sync/support/date_time.hpp>
+//#include <boost/thread/recursive_mutex.hpp>
+//#include <boost/thread/thread_time.hpp>
+//#include <boost/thread/condition.hpp>
+
+#include "utils.hpp"
+
+template <typename M>
+struct test_lock
+{
+    typedef M mutex_type;
+    typedef boost::sync::unique_lock< mutex_type > lock_type;
+
+    void operator()() const
+    {
+        mutex_type mutex;
+//        boost::condition condition;
+
+        // Test the lock's constructors.
+        {
+            lock_type lock(mutex, boost::sync::defer_lock);
+            BOOST_CHECK(!lock);
+        }
+        lock_type lock(mutex);
+        BOOST_CHECK(lock ? true : false);
+/*
+        // Construct and initialize an xtime for a fast time out.
+        boost::xtime xt = delay(0, 100);
+
+        // Test the lock and the mutex with condition variables.
+        // No one is going to notify this condition variable.  We expect to
+        // time out.
+        BOOST_CHECK(!condition.timed_wait(lock, xt));
+        BOOST_CHECK(lock ? true : false);
+*/
+        // Test the lock and unlock methods.
+        lock.unlock();
+        BOOST_CHECK(!lock);
+        lock.lock();
+        BOOST_CHECK(lock ? true : false);
+    }
+};
+
+template <typename M>
+struct test_trylock
+{
+    typedef M mutex_type;
+    typedef boost::sync::unique_lock< mutex_type > lock_type;
+
+    void operator()()
+    {
+        mutex_type mutex;
+//        boost::condition condition;
+
+        // Test the lock's constructors.
+        {
+            lock_type lock(mutex, boost::sync::try_to_lock);
+            BOOST_CHECK(lock ? true : false);
+        }
+        {
+            lock_type lock(mutex, boost::sync::defer_lock);
+            BOOST_CHECK(!lock);
+        }
+        lock_type lock(mutex, boost::sync::try_to_lock);
+        BOOST_CHECK(lock ? true : false);
+/*
+        // Construct and initialize an xtime for a fast time out.
+        boost::xtime xt = delay(0, 100);
+
+        // Test the lock and the mutex with condition variables.
+        // No one is going to notify this condition variable.  We expect to
+        // time out.
+        BOOST_CHECK(!condition.timed_wait(lock, xt));
+        BOOST_CHECK(lock ? true : false);
+*/
+        // Test the lock, unlock and trylock methods.
+        lock.unlock();
+        BOOST_CHECK(!lock);
+        lock.lock();
+        BOOST_CHECK(lock ? true : false);
+        lock.unlock();
+        BOOST_CHECK(!lock);
+        BOOST_CHECK(lock.try_lock());
+        BOOST_CHECK(lock ? true : false);
+    }
+};
+/*
+template<typename Mutex>
+struct test_lock_times_out_if_other_thread_has_lock
+{
+    typedef boost::unique_lock<Mutex> Lock;
+
+    Mutex m;
+    boost::mutex done_mutex;
+    bool done;
+    bool locked;
+    boost::condition_variable done_cond;
+
+    test_lock_times_out_if_other_thread_has_lock():
+        done(false),locked(false)
+    {}
+
+    void locking_thread()
+    {
+        Lock lock(m,boost::defer_lock);
+        lock.timed_lock(boost::posix_time::milliseconds(50));
+
+        boost::lock_guard<boost::mutex> lk(done_mutex);
+        locked=lock.owns_lock();
+        done=true;
+        done_cond.notify_one();
+    }
+
+    void locking_thread_through_constructor()
+    {
+        Lock lock(m,boost::posix_time::milliseconds(50));
+
+        boost::lock_guard<boost::mutex> lk(done_mutex);
+        locked=lock.owns_lock();
+        done=true;
+        done_cond.notify_one();
+    }
+
+    bool is_done() const
+    {
+        return done;
+    }
+
+    typedef test_lock_times_out_if_other_thread_has_lock<Mutex> this_type;
+
+    void do_test(void (this_type::*test_func)())
+    {
+        Lock lock(m);
+
+        locked=false;
+        done=false;
+
+        boost::thread t(test_func,this);
+
+        try
+        {
+            {
+                boost::unique_lock<boost::mutex> lk(done_mutex);
+                BOOST_CHECK(done_cond.timed_wait(lk,boost::posix_time::seconds(2),
+                                                 boost::bind(&this_type::is_done,this)));
+                BOOST_CHECK(!locked);
+            }
+
+            lock.unlock();
+            t.join();
+        }
+        catch(...)
+        {
+            lock.unlock();
+            t.join();
+            throw;
+        }
+    }
+
+
+    void operator()()
+    {
+        do_test(&this_type::locking_thread);
+        do_test(&this_type::locking_thread_through_constructor);
+    }
+};
+
+template <typename M>
+struct test_timedlock
+{
+    typedef M mutex_type;
+    typedef typename M::scoped_timed_lock timed_lock_type;
+
+    static bool fake_predicate()
+    {
+        return false;
+    }
+
+    void operator()()
+    {
+        test_lock_times_out_if_other_thread_has_lock<mutex_type>()();
+
+        mutex_type mutex;
+        boost::condition condition;
+
+        // Test the lock's constructors.
+        {
+            // Construct and initialize an xtime for a fast time out.
+            boost::system_time xt = boost::get_system_time()+boost::posix_time::milliseconds(100);
+
+            timed_lock_type lock(mutex, xt);
+            BOOST_CHECK(lock ? true : false);
+        }
+        {
+            timed_lock_type lock(mutex, boost::defer_lock);
+            BOOST_CHECK(!lock);
+        }
+        timed_lock_type lock(mutex);
+        BOOST_CHECK(lock ? true : false);
+
+        // Construct and initialize an xtime for a fast time out.
+        boost::system_time timeout = boost::get_system_time()+boost::posix_time::milliseconds(100);
+
+        // Test the lock and the mutex with condition variables.
+        // No one is going to notify this condition variable.  We expect to
+        // time out.
+        BOOST_CHECK(!condition.timed_wait(lock, timeout, fake_predicate));
+        BOOST_CHECK(lock ? true : false);
+
+        boost::system_time now=boost::get_system_time();
+        boost::posix_time::milliseconds const timeout_resolution(20);
+        BOOST_CHECK((timeout-timeout_resolution)<now);
+
+        // Test the lock, unlock and timedlock methods.
+        lock.unlock();
+        BOOST_CHECK(!lock);
+        lock.lock();
+        BOOST_CHECK(lock ? true : false);
+        lock.unlock();
+        BOOST_CHECK(!lock);
+        boost::system_time target = boost::get_system_time()+boost::posix_time::milliseconds(100);
+        BOOST_CHECK(lock.timed_lock(target));
+        BOOST_CHECK(lock ? true : false);
+        lock.unlock();
+        BOOST_CHECK(!lock);
+
+        BOOST_CHECK(mutex.timed_lock(boost::posix_time::milliseconds(100)));
+        mutex.unlock();
+
+        BOOST_CHECK(lock.timed_lock(boost::posix_time::milliseconds(100)));
+        BOOST_CHECK(lock ? true : false);
+        lock.unlock();
+        BOOST_CHECK(!lock);
+    }
+};
+
+template <typename M>
+struct test_recursive_lock
+{
+    typedef M mutex_type;
+    typedef sync::unique_lock< mutex_type > lock_type;
+
+    void operator()()
+    {
+        mutex_type mx;
+        lock_type lock1(mx);
+        lock_type lock2(mx);
+    }
+};
+*/
+
+
+void do_test_mutex()
+{
+    test_lock<boost::sync::mutex>()();
+}
+
+BOOST_AUTO_TEST_CASE(test_mutex)
+{
+    timed_test(&do_test_mutex, 3);
+}
+
+void do_test_try_mutex()
+{
+    test_trylock<boost::sync::mutex>()();
+}
+BOOST_AUTO_TEST_CASE(test_try_mutex)
+{
+    timed_test(&do_test_try_mutex, 3);
+}
+
+/*
+void do_test_timed_mutex()
+{
+    test_lock<sync::timed_mutex>()();
+    test_trylock<sync::timed_mutex>()();
+    test_timedlock<sync::timed_mutex>()();
+}
+
+BOOST_AUTO_TEST_CASE(test_timed_mutex)
+{
+    timed_test(&do_test_timed_mutex, 3);
+}
+
+void do_test_recursive_mutex()
+{
+    test_lock<boost::recursive_mutex>()();
+    test_recursive_lock<boost::recursive_mutex>()();
+}
+
+void test_recursive_mutex()
+{
+    timed_test(&do_test_recursive_mutex, 3);
+}
+
+void do_test_recursive_try_mutex()
+{
+    test_lock<boost::recursive_try_mutex>()();
+    test_trylock<boost::recursive_try_mutex>()();
+    test_recursive_lock<boost::recursive_try_mutex>()();
+}
+
+void test_recursive_try_mutex()
+{
+    timed_test(&do_test_recursive_try_mutex, 3);
+}
+
+void do_test_recursive_timed_mutex()
+{
+    test_lock<boost::recursive_timed_mutex>()();
+    test_trylock<boost::recursive_timed_mutex>()();
+    test_timedlock<boost::recursive_timed_mutex>()();
+    test_recursive_lock<boost::recursive_timed_mutex>()();
+}
+
+void test_recursive_timed_mutex()
+{
+    timed_test(&do_test_recursive_timed_mutex, 3);
+}
+*/

Copied: trunk/libs/sync/test/run/semaphore_test.cpp (from r85792, trunk/libs/sync/test/semaphore_test.cpp)
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/test/run/semaphore_test.cpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85794, copy of r85792, trunk/libs/sync/test/semaphore_test.cpp)
@@ -0,0 +1,113 @@
+// Copyright (C) 2013 Tim Blechmann
+//
+//  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)
+
+#include <boost/test/unit_test.hpp>
+
+#include <boost/thread.hpp>
+#include <boost/sync/semaphore.hpp>
+
+#include <boost/typeof/typeof.hpp>
+
+BOOST_AUTO_TEST_CASE(test_semaphore_post_wait)
+{
+    boost::sync::semaphore sem(0);
+
+    sem.post();
+    sem.wait();
+}
+
+
+BOOST_AUTO_TEST_CASE(test_semaphore_try_wait)
+{
+    boost::sync::semaphore sem(0);
+
+    BOOST_REQUIRE(!sem.try_wait());
+    sem.post();
+    BOOST_REQUIRE(sem.try_wait());
+}
+
+
+struct semaphore_wait_and_post_test
+{
+    void run()
+    {
+        boost::thread post_thread(boost::bind(&semaphore_wait_and_post_test::wait_and_post, this));
+        sem_.wait();
+    }
+
+    void wait_and_post()
+    {
+        boost::this_thread::sleep_for(boost::chrono::seconds(1));
+        sem_.post();
+    }
+
+    boost::sync::semaphore sem_;
+    boost::thread thread_;
+};
+
+BOOST_AUTO_TEST_CASE(semaphore_wait_and_post)
+{
+    semaphore_wait_and_post_test test;
+    test.run();
+}
+
+#ifdef BOOST_SYNC_USES_CHRONO
+
+BOOST_AUTO_TEST_CASE(test_semaphore_wait_for)
+{
+    using namespace boost;
+
+    sync::semaphore sem(0);
+
+    BOOST_AUTO(start, chrono::system_clock::now());
+
+    BOOST_REQUIRE(!sem.try_wait_for(chrono::milliseconds(500)));
+
+    BOOST_AUTO(end, chrono::system_clock::now());
+    BOOST_AUTO(wait_time, end - start);
+
+    // guessing!
+    BOOST_REQUIRE( wait_time > chrono::milliseconds(450) );
+    BOOST_REQUIRE( wait_time < chrono::milliseconds(1000) );
+
+    sem.post();
+
+    BOOST_REQUIRE(sem.try_wait_for(chrono::milliseconds(500)));
+}
+
+BOOST_AUTO_TEST_CASE(test_semaphore_wait_until)
+{
+    using namespace boost;
+
+    sync::semaphore sem(0);
+    {
+        BOOST_AUTO(now, chrono::system_clock::now());
+        BOOST_AUTO(timeout, now + chrono::milliseconds(500));
+
+        BOOST_REQUIRE(!sem.try_wait_until(timeout));
+
+        BOOST_AUTO(end, chrono::system_clock::now());
+        BOOST_AUTO(timeout_delta, end - timeout);
+
+        // guessing!
+        BOOST_REQUIRE( timeout_delta > chrono::milliseconds(-400) );
+        BOOST_REQUIRE( timeout_delta < chrono::milliseconds(400) );
+    }
+
+    sem.post();
+
+    {
+        BOOST_AUTO(start,   chrono::system_clock::now());
+        BOOST_AUTO(timeout, start + chrono::milliseconds(500));
+
+        BOOST_REQUIRE(sem.try_wait_until(timeout));
+
+        BOOST_AUTO(end, chrono::system_clock::now());
+
+        // guessing!
+        BOOST_REQUIRE( (end - start) < chrono::milliseconds(100) );
+    }
+}
+#endif

Added: trunk/libs/sync/test/run/utils.hpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/test/run/utils.hpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85794)
@@ -0,0 +1,223 @@
+// Copyright (C) 2001-2003
+// William E. Kempf
+// Copyright (C) 2007-8 Anthony Williams
+//
+//  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)
+
+#if !defined(UTIL_INL_WEK01242003)
+#define UTIL_INL_WEK01242003
+
+#include <boost/thread/xtime.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
+
+#ifndef DEFAULT_EXECUTION_MONITOR_TYPE
+#   define DEFAULT_EXECUTION_MONITOR_TYPE execution_monitor::use_condition
+#endif
+
+// boostinspect:nounnamed
+
+
+
+namespace
+{
+inline boost::xtime delay(int secs, int msecs=0, int nsecs=0)
+{
+    const int MILLISECONDS_PER_SECOND = 1000;
+    const int NANOSECONDS_PER_SECOND = 1000000000;
+    const int NANOSECONDS_PER_MILLISECOND = 1000000;
+
+    boost::xtime xt;
+    if (boost::TIME_UTC_ != boost::xtime_get (&xt, boost::TIME_UTC_))
+        BOOST_ERROR ("boost::xtime_get != boost::TIME_UTC_");
+
+    nsecs += xt.nsec;
+    msecs += nsecs / NANOSECONDS_PER_MILLISECOND;
+    secs += msecs / MILLISECONDS_PER_SECOND;
+    nsecs += (msecs % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
+    xt.nsec = nsecs % NANOSECONDS_PER_SECOND;
+    xt.sec += secs + (nsecs / NANOSECONDS_PER_SECOND);
+
+    return xt;
+}
+
+}
+namespace boost
+{
+namespace threads
+{
+namespace test
+{
+inline bool in_range(const boost::xtime& xt, int secs=1)
+{
+    boost::xtime min = delay(-secs);
+    boost::xtime max = delay(0);
+    return (boost::xtime_cmp(xt, min) >= 0) &&
+        (boost::xtime_cmp(xt, max) <= 0);
+}
+}
+}
+}
+
+
+namespace
+{
+class execution_monitor
+{
+public:
+    enum wait_type { use_sleep_only, use_mutex, use_condition };
+
+    execution_monitor(wait_type type, int secs)
+        : done(false), type(type), secs(secs) { }
+    void start()
+    {
+        if (type != use_sleep_only) {
+            boost::unique_lock<boost::mutex> lock(mutex); done = false;
+        } else {
+            done = false;
+        }
+    }
+    void finish()
+    {
+        if (type != use_sleep_only) {
+            boost::unique_lock<boost::mutex> lock(mutex);
+            done = true;
+            if (type == use_condition)
+                cond.notify_one();
+        } else {
+            done = true;
+        }
+    }
+    bool wait()
+    {
+        boost::xtime xt = delay(secs);
+        if (type != use_condition)
+            boost::thread::sleep(xt);
+        if (type != use_sleep_only) {
+            boost::unique_lock<boost::mutex> lock(mutex);
+            while (type == use_condition && !done) {
+                if (!cond.timed_wait(lock, xt))
+                    break;
+            }
+            return done;
+        }
+        return done;
+    }
+
+private:
+    boost::mutex mutex;
+    boost::condition cond;
+    bool done;
+    wait_type type;
+    int secs;
+};
+}
+namespace thread_detail_anon
+{
+template <typename F>
+class indirect_adapter
+{
+public:
+    indirect_adapter(F func, execution_monitor& monitor)
+        : func(func), monitor(monitor) { }
+    void operator()() const
+    {
+        try
+        {
+            boost::thread thrd(func);
+            thrd.join();
+        }
+        catch (...)
+        {
+            monitor.finish();
+            throw;
+        }
+        monitor.finish();
+    }
+
+private:
+    F func;
+    execution_monitor& monitor;
+    void operator=(indirect_adapter&);
+};
+
+}
+// boostinspect:nounnamed
+namespace 
+{
+
+template <typename F>
+void timed_test(F func, int secs,
+    execution_monitor::wait_type type=DEFAULT_EXECUTION_MONITOR_TYPE)
+{
+    execution_monitor monitor(type, secs);
+    thread_detail_anon::indirect_adapter<F> ifunc(func, monitor);
+    monitor.start();
+    boost::thread thrd(ifunc);
+    BOOST_REQUIRE_MESSAGE(monitor.wait(),
+        "Timed test didn't complete in time, possible deadlock.");
+}
+
+}
+
+namespace thread_detail_anon
+{
+
+template <typename F, typename T>
+class thread_binder
+{
+public:
+    thread_binder(const F& func, const T& param)
+        : func(func), param(param) { }
+    void operator()() const { func(param); }
+
+private:
+    F func;
+    T param;
+};
+
+}
+
+// boostinspect:nounnamed
+namespace 
+{
+template <typename F, typename T>
+thread_detail_anon::thread_binder<F, T> bind(const F& func, const T& param)
+{
+    return thread_detail_anon::thread_binder<F, T>(func, param);
+}
+}
+
+namespace thread_detail_anon
+{
+
+template <typename R, typename T>
+class thread_member_binder
+{
+public:
+    thread_member_binder(R (T::*func)(), T& param)
+        : func(func), param(param) { }
+    void operator()() const { (param.*func)(); }
+
+private:
+    void operator=(thread_member_binder&);
+    
+    R (T::*func)();
+    T& param;
+};
+
+}
+
+// boostinspect:nounnamed
+namespace 
+{
+template <typename R, typename T>
+thread_detail_anon::thread_member_binder<R, T> bind(R (T::*func)(), T& param)
+{
+    return thread_detail_anon::thread_member_binder<R, T>(func, param);
+}
+} // namespace
+
+#endif

Deleted: trunk/libs/sync/test/semaphore_test.cpp
==============================================================================
--- trunk/libs/sync/test/semaphore_test.cpp	2013-09-19 16:27:08 EDT (Thu, 19 Sep 2013)	(r85793)
+++ /dev/null	00:00:00 1970	(deleted)
@@ -1,113 +0,0 @@
-// Copyright (C) 2013 Tim Blechmann
-//
-//  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)
-
-#include <boost/test/unit_test.hpp>
-
-#include <boost/thread.hpp>
-#include <boost/sync/semaphore.hpp>
-
-#include <boost/typeof/typeof.hpp>
-
-BOOST_AUTO_TEST_CASE(test_semaphore_post_wait)
-{
-    boost::sync::semaphore sem(0);
-
-    sem.post();
-    sem.wait();
-}
-
-
-BOOST_AUTO_TEST_CASE(test_semaphore_try_wait)
-{
-    boost::sync::semaphore sem(0);
-
-    BOOST_REQUIRE(!sem.try_wait());
-    sem.post();
-    BOOST_REQUIRE(sem.try_wait());
-}
-
-
-struct semaphore_wait_and_post_test
-{
-    void run()
-    {
-        boost::thread post_thread(boost::bind(&semaphore_wait_and_post_test::wait_and_post, this));
-        sem_.wait();
-    }
-
-    void wait_and_post()
-    {
-        boost::this_thread::sleep_for(boost::chrono::seconds(1));
-        sem_.post();
-    }
-
-    boost::sync::semaphore sem_;
-    boost::thread thread_;
-};
-
-BOOST_AUTO_TEST_CASE(semaphore_wait_and_post)
-{
-    semaphore_wait_and_post_test test;
-    test.run();
-}
-
-#ifdef BOOST_SYNC_USES_CHRONO
-
-BOOST_AUTO_TEST_CASE(test_semaphore_wait_for)
-{
-    using namespace boost;
-
-    sync::semaphore sem(0);
-
-    BOOST_AUTO(start, chrono::system_clock::now());
-
-    BOOST_REQUIRE(!sem.try_wait_for(chrono::milliseconds(500)));
-
-    BOOST_AUTO(end, chrono::system_clock::now());
-    BOOST_AUTO(wait_time, end - start);
-
-    // guessing!
-    BOOST_REQUIRE( wait_time > chrono::milliseconds(450) );
-    BOOST_REQUIRE( wait_time < chrono::milliseconds(1000) );
-
-    sem.post();
-
-    BOOST_REQUIRE(sem.try_wait_for(chrono::milliseconds(500)));
-}
-
-BOOST_AUTO_TEST_CASE(test_semaphore_wait_until)
-{
-    using namespace boost;
-
-    sync::semaphore sem(0);
-    {
-        BOOST_AUTO(now, chrono::system_clock::now());
-        BOOST_AUTO(timeout, now + chrono::milliseconds(500));
-
-        BOOST_REQUIRE(!sem.try_wait_until(timeout));
-
-        BOOST_AUTO(end, chrono::system_clock::now());
-        BOOST_AUTO(timeout_delta, end - timeout);
-
-        // guessing!
-        BOOST_REQUIRE( timeout_delta > chrono::milliseconds(-400) );
-        BOOST_REQUIRE( timeout_delta < chrono::milliseconds(400) );
-    }
-
-    sem.post();
-
-    {
-        BOOST_AUTO(start,   chrono::system_clock::now());
-        BOOST_AUTO(timeout, start + chrono::milliseconds(500));
-
-        BOOST_REQUIRE(sem.try_wait_until(timeout));
-
-        BOOST_AUTO(end, chrono::system_clock::now());
-
-        // guessing!
-        BOOST_REQUIRE( (end - start) < chrono::milliseconds(100) );
-    }
-}
-#endif