Branch for developing Bitten client/server testing

[SVN r41004]
2026-02-06 10:32:14 +00:00 · 2007-11-10 22:53:12 +00:00
21 changed files with 226 additions and 260 deletions
--- a/build/Jamfile.v2
+++ b/build/Jamfile.v2
@@ -75,84 +75,6 @@ rule tag ( name : type ? : property-set )
                $(result) : $(type) : $(property-set) ] ;
 }

-rule win32_pthread_paths ( properties * )
-{
-    local result ;
-    local PTW32_INCLUDE ;
-    local PTW32_LIB ;
-    PTW32_INCLUDE  = [ modules.peek             : PTW32_INCLUDE ] ;
-    PTW32_LIB      = [ modules.peek             : PTW32_LIB     ] ;
-    PTW32_INCLUDE ?= [ modules.peek user-config : PTW32_INCLUDE ] ;
-    PTW32_LIB     ?= [ modules.peek user-config : PTW32_LIB     ] ;
-    PTW32_INCLUDE ?= [ modules.peek site-config : PTW32_INCLUDE ] ;
-    PTW32_LIB     ?= [ modules.peek site-config : PTW32_LIB     ] ;
-
-    if ! ( $(PTW32_INCLUDE) && $(PTW32_LIB) )
-    {
-        if  ! $(.notified)
-        {
-            echo "************************************************************" ;
-            echo "Trying to build Boost.Thread with pthread support."           ;
-            echo "If you need pthread you should specify the paths."            ;
-            echo "You can specify them in site-config.jam, user-config.jam"     ;
-            echo "or in the environment."                                       ;
-            echo "For example:"                                                 ;
-            echo "PTW32_INCLUDE=C:\\Program Files\\ptw32\\Pre-built2\\include"  ;
-            echo "PTW32_LIB=C:\\Program Files\\ptw32\\Pre-built2\\lib"          ;
-            echo "************************************************************" ;
-            .notified = true ;
-        }
-    }
-    else
-    {
-        local include_path = [ path.make $(PTW32_INCLUDE) ] ;
-        local lib_path = [ path.make $(PTW32_LIB) ] ;
-        local libname = pthread ;
-        if <toolset>msvc in $(properties)
-        {
-            libname = $(libname)VC2.lib ;
-        }
-        if <toolset>gcc in $(properties)
-        {
-            libname = lib$(libname)GC2.a ;
-        }
-        lib_path = [ path.glob $(lib_path) : $(libname) ] ;
-        if ! $(lib_path)
-        {
-            if  ! $(.notified)
-            {
-                echo "************************************************************" ;
-                echo "Trying to build Boost.Thread with pthread support."           ;
-                echo "But the library" $(libname) "could not be found in path"      ;
-                echo $(PTW32_LIB)                                                   ;
-                echo "************************************************************" ;
-                .notified = true ;
-            }
-        }
-        else 
-        {
-            result += <include>$(include_path) ;
-            result += <library>$(lib_path) ;
-        }
-    }
-    return $(result) ;
-}
-
-rule usage-requirements ( properties * )
-{
-    local result ;
-    if <threadapi>pthread in $(properties)
-    {
-        result += <define>BOOST_THREAD_POSIX ;
-        if <target-os>windows in $(properties)
-        {
-            result += [ win32_pthread_paths $(properties) ] ;
-            # TODO: What is for static linking? Is the <library> also needed
-            # in that case?
-        }
-    }
-    return $(result) ;
-}

 rule requirements ( properties * )
 {
@@ -162,14 +84,62 @@ rule requirements ( properties * )
        result += <define>BOOST_THREAD_POSIX ;
        if <target-os>windows in $(properties) 
        {
-            local paths = [ win32_pthread_paths $(properties) ] ;
-            if $(paths)
+            local PTW32_INCLUDE ;
+            local PTW32_LIB ;
+            PTW32_INCLUDE  = [ modules.peek             : PTW32_INCLUDE ] ;
+            PTW32_LIB      = [ modules.peek             : PTW32_LIB     ] ;
+            PTW32_INCLUDE ?= [ modules.peek user-config : PTW32_INCLUDE ] ;
+            PTW32_LIB     ?= [ modules.peek user-config : PTW32_LIB     ] ;
+            PTW32_INCLUDE ?= [ modules.peek site-config : PTW32_INCLUDE ] ;
+            PTW32_LIB     ?= [ modules.peek site-config : PTW32_LIB     ] ;
+
+            if ! ( $(PTW32_INCLUDE) && $(PTW32_LIB) )
            {
-                result += $(paths) ;
+                if  ! $(.notified)
+                {
+                    echo "************************************************************" ;
+                    echo "Trying to build Boost.Thread with pthread support."           ;
+                    echo "If you need pthread you should specify the paths."            ;
+                    echo "You can specify them in site-config.jam, user-config.jam"     ;
+                    echo "or in the environment."                                       ;
+                    echo "For example:"                                                 ;
+                    echo "PTW32_INCLUDE=C:\\Program Files\\ptw32\\Pre-built2\\include"  ;
+                    echo "PTW32_LIB=C:\\Program Files\\ptw32\\Pre-built2\\lib"          ;
+                    echo "************************************************************" ;
+                    .notified = true ;
+                }
+                result = <build>no ;
            }
            else
            {
-                result = <build>no ;
+                local include_path = [ path.make $(PTW32_INCLUDE) ] ;
+                local lib_path = [ path.make $(PTW32_LIB) ] ;
+                result += <include>$(include_path) ;
+                local libname = pthread ;
+                if <toolset>msvc in $(properties)
+                {
+                    libname = $(libname)VC2.lib ;
+                }
+                if <toolset>gcc in $(properties)
+                {
+                    libname = lib$(libname)GC2.a ;
+                }
+                lib_path = [ path.glob $(lib_path) : $(libname) ] ;
+                if ! $(lib_path)
+                {
+                    if  ! $(.notified)
+                    {
+                        echo "************************************************************" ;
+                        echo "Trying to build Boost.Thread with pthread support."           ;
+                        echo "But the library" $(libname) "could not be found in path"      ;
+                        echo $(PTW32_LIB)                                                   ;
+                        echo "************************************************************" ;
+                        .notified = true ;
+                    }
+                    result = <build>no ;
+                }
+                result += <library>$(lib_path) ;
+            
            }
        }
    }
@@ -202,6 +172,4 @@ explicit thread_sources ;
 lib boost_thread
    : thread_sources
    : <conditional>@requirements
-    :
-    : <conditional>@usage-requirements
    ;
--- a/include/boost/thread/condition.hpp
+++ b/include/boost/thread/condition.hpp
@@ -1,11 +1,5 @@
 #ifndef BOOST_THREAD_CONDITION_HPP
 #define BOOST_THREAD_CONDITION_HPP
-//  (C) Copyright 2007 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)
-
 #include <boost/thread/condition_variable.hpp>

 namespace boost
--- a/include/boost/thread/pthread/condition_variable.hpp
+++ b/include/boost/thread/pthread/condition_variable.hpp
@@ -28,13 +28,15 @@ namespace boost
    }
    inline condition_variable::~condition_variable()
    {
-        BOOST_VERIFY(!pthread_cond_destroy(&cond));
+        int const res=pthread_cond_destroy(&cond);
+        BOOST_ASSERT(!res);
    }

    inline void condition_variable::wait(unique_lock<mutex>& m)
    {
        detail::interruption_checker check_for_interruption(&cond);
-        BOOST_VERIFY(!pthread_cond_wait(&cond,m.mutex()->native_handle()));
+        int const cond_res=pthread_cond_wait(&cond,m.mutex()->native_handle());
+        BOOST_ASSERT(!cond_res);
    }

    inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
@@ -52,12 +54,14 @@ namespace boost

    inline void condition_variable::notify_one()
    {
-        BOOST_VERIFY(!pthread_cond_signal(&cond));
+        int const res=pthread_cond_signal(&cond);
+        BOOST_ASSERT(!res);
    }
        
    inline void condition_variable::notify_all()
    {
-        BOOST_VERIFY(!pthread_cond_broadcast(&cond));
+        int const res=pthread_cond_broadcast(&cond);
+        BOOST_ASSERT(!res);
    }
    
    class condition_variable_any
@@ -79,14 +83,17 @@ namespace boost
            int const res2=pthread_cond_init(&cond,NULL);
            if(res2)
            {
-                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+                int const destroy_res=pthread_mutex_destroy(&internal_mutex);
+                BOOST_ASSERT(!destroy_res);
                throw thread_resource_error();
            }
        }
        ~condition_variable_any()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            int const res=pthread_mutex_destroy(&internal_mutex);
+            BOOST_ASSERT(!res);
+            int const res2=pthread_cond_destroy(&cond);
+            BOOST_ASSERT(!res2);
        }
        
        template<typename lock_type>
@@ -153,13 +160,15 @@ namespace boost
        void notify_one()
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            int const res=pthread_cond_signal(&cond);
+            BOOST_ASSERT(!res);
        }
        
        void notify_all()
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-            BOOST_VERIFY(!pthread_cond_broadcast(&cond));
+            int const res=pthread_cond_broadcast(&cond);
+            BOOST_ASSERT(!res);
        }
    };

--- a/include/boost/thread/pthread/mutex.hpp
+++ b/include/boost/thread/pthread/mutex.hpp
@@ -42,17 +42,20 @@ namespace boost
        }
        ~mutex()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+            int const res=pthread_mutex_destroy(&m);
+            BOOST_ASSERT(!res);
        }
        
        void lock()
        {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            int const res=pthread_mutex_lock(&m);
+            BOOST_ASSERT(!res);
        }

        void unlock()
        {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            int const res=pthread_mutex_unlock(&m);
+            BOOST_ASSERT(!res);
        }
        
        bool try_lock()
@@ -95,7 +98,8 @@ namespace boost
            int const res2=pthread_cond_init(&cond,NULL);
            if(res2)
            {
-                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                int const destroy_res=pthread_mutex_destroy(&m);
+                BOOST_ASSERT(!destroy_res);
                throw thread_resource_error();
            }
            is_locked=false;
@@ -103,9 +107,11 @@ namespace boost
        }
        ~timed_mutex()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+            int const res=pthread_mutex_destroy(&m);
+            BOOST_ASSERT(!res);
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            int const res2=pthread_cond_destroy(&cond);
+            BOOST_ASSERT(!res2);
 #endif
        }

@@ -118,12 +124,14 @@ namespace boost
 #ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
        void lock()
        {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            int const res=pthread_mutex_lock(&m);
+            BOOST_ASSERT(!res);
        }

        void unlock()
        {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            int const res=pthread_mutex_unlock(&m);
+            BOOST_ASSERT(!res);
        }
        
        bool try_lock()
@@ -145,7 +153,8 @@ namespace boost
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            while(is_locked)
            {
-                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+                int const cond_res=pthread_cond_wait(&cond,&m);
+                BOOST_ASSERT(!cond_res);
            }
            is_locked=true;
        }
@@ -154,7 +163,8 @@ namespace boost
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            is_locked=false;
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            int const res=pthread_cond_signal(&cond);
+            BOOST_ASSERT(!res);
        }
        
        bool try_lock()
--- a/include/boost/thread/pthread/once.hpp
+++ b/include/boost/thread/pthread/once.hpp
@@ -13,28 +13,47 @@

 #include <pthread.h>
 #include <boost/assert.hpp>
-#include "pthread_mutex_scoped_lock.hpp"

 namespace boost {

    struct once_flag
    {
        pthread_mutex_t mutex;
-        unsigned long flag;
+        unsigned flag;
    };

 #define BOOST_ONCE_INIT {PTHREAD_MUTEX_INITIALIZER,0}

+    namespace detail
+    {
+        struct pthread_mutex_scoped_lock
+        {
+            pthread_mutex_t * mutex;
+            
+            explicit pthread_mutex_scoped_lock(pthread_mutex_t* mutex_):
+                mutex(mutex_)
+            {
+                int const res=pthread_mutex_lock(mutex);
+                BOOST_ASSERT(!res);
+            }
+            ~pthread_mutex_scoped_lock()
+            {
+                int const res=pthread_mutex_unlock(mutex);
+                BOOST_ASSERT(!res);
+            }
+        };
+    }
+
    template<typename Function>
    void call_once(once_flag& flag,Function f)
    {
-        unsigned long const function_complete_flag_value=0xc15730e2ul;
+        long const function_complete_flag_value=0xc15730e2;

 #ifdef BOOST_PTHREAD_HAS_ATOMICS
        if(::boost::detail::interlocked_read_acquire(&flag.flag)!=function_complete_flag_value)
        {
 #endif
-            pthread::pthread_mutex_scoped_lock const lock(&flag.mutex);
+            detail::pthread_mutex_scoped_lock const lock(&flag.mutex);
            if(flag.flag!=function_complete_flag_value)
            {
                f();
--- a/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp
+++ b/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp
@@ -1,11 +1,5 @@
 #ifndef BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
 #define BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
-//  (C) Copyright 2007 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)
-
 #include <pthread.h>
 #include <boost/assert.hpp>

@@ -20,11 +14,13 @@ namespace boost
            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
                m(m_)
            {
-                BOOST_VERIFY(!pthread_mutex_lock(m));
+                int const res=pthread_mutex_lock(m);
+                BOOST_ASSERT(!res);
            }
            ~pthread_mutex_scoped_lock()
            {
-                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                int const res=pthread_mutex_unlock(m);
+                BOOST_ASSERT(!res);
            }
            
        };
--- a/include/boost/thread/pthread/recursive_mutex.hpp
+++ b/include/boost/thread/pthread/recursive_mutex.hpp
@@ -53,21 +53,25 @@ namespace boost
            {
                throw thread_resource_error();
            }
-            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+            int const destroy_attr_res=pthread_mutexattr_destroy(&attr);
+            BOOST_ASSERT(!destroy_attr_res);
        }
        ~recursive_mutex()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+            int const res=pthread_mutex_destroy(&m);
+            BOOST_ASSERT(!res);
        }
        
        void lock()
        {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            int const res=pthread_mutex_lock(&m);
+            BOOST_ASSERT(!res);
        }

        void unlock()
        {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            int const res=pthread_mutex_unlock(&m);
+            BOOST_ASSERT(!res);
        }
        
        bool try_lock()
@@ -113,10 +117,12 @@ namespace boost
            int const res=pthread_mutex_init(&m,&attr);
            if(res)
            {
-                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+                int const destroy_attr_res=pthread_mutexattr_destroy(&attr);
+                BOOST_ASSERT(!destroy_attr_res);
                throw thread_resource_error();
            }
-            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
+            int const destroy_attr_res=pthread_mutexattr_destroy(&attr);
+            BOOST_ASSERT(!destroy_attr_res);
 #else
            int const res=pthread_mutex_init(&m,NULL);
            if(res)
@@ -126,7 +132,8 @@ namespace boost
            int const res2=pthread_cond_init(&cond,NULL);
            if(res2)
            {
-                BOOST_VERIFY(!pthread_mutex_destroy(&m));
+                int const destroy_res=pthread_mutex_destroy(&m);
+                BOOST_ASSERT(!destroy_res);
                throw thread_resource_error();
            }
            is_locked=false;
@@ -135,9 +142,11 @@ namespace boost
        }
        ~recursive_timed_mutex()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+            int const res=pthread_mutex_destroy(&m);
+            BOOST_ASSERT(!res);
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            int const res2=pthread_cond_destroy(&cond);
+            BOOST_ASSERT(!res2);
 #endif
        }

@@ -150,12 +159,14 @@ namespace boost
 #ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
        void lock()
        {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            int const res=pthread_mutex_lock(&m);
+            BOOST_ASSERT(!res);
        }

        void unlock()
        {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            int const res=pthread_mutex_unlock(&m);
+            BOOST_ASSERT(!res);
        }
        
        bool try_lock()
@@ -175,7 +186,7 @@ namespace boost
        void lock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
-            if(is_locked && pthread_equal(owner,pthread_self()))
+            if(is_locked && owner==pthread_self())
            {
                ++count;
                return;
@@ -183,7 +194,8 @@ namespace boost
            
            while(is_locked)
            {
-                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+                int const cond_res=pthread_cond_wait(&cond,&m);
+                BOOST_ASSERT(!cond_res);
            }
            is_locked=true;
            ++count;
@@ -197,13 +209,14 @@ namespace boost
            {
                is_locked=false;
            }
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            int const res=pthread_cond_signal(&cond);
+            BOOST_ASSERT(!res);
        }
        
        bool try_lock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
-            if(is_locked && !pthread_equal(owner,pthread_self()))
+            if(is_locked && owner!=pthread_self())
            {
                return false;
            }
@@ -217,7 +230,7 @@ namespace boost
        {
            struct timespec const timeout=detail::get_timespec(abs_time);
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
-            if(is_locked && pthread_equal(owner,pthread_self()))
+            if(is_locked && owner==pthread_self())
            {
                ++count;
                return true;
--- a/include/boost/thread/pthread/shared_mutex.hpp
+++ b/include/boost/thread/pthread/shared_mutex.hpp
@@ -10,7 +10,6 @@
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
 #include <boost/thread/condition_variable.hpp>

 namespace boost
--- a/include/boost/thread/pthread/thread.hpp
+++ b/include/boost/thread/pthread/thread.hpp
@@ -33,7 +33,7 @@ namespace boost
    
    namespace this_thread
    {
-        BOOST_THREAD_DECL detail::thread_id get_id();
+        detail::thread_id get_id();
    }
    
    namespace detail
@@ -208,22 +208,22 @@ namespace boost
            ~restore_interruption();
        };

-        BOOST_THREAD_DECL inline thread::id get_id()
+        inline thread::id get_id()
        {
            return thread::id(pthread_self());
        }

-        BOOST_THREAD_DECL void interruption_point();
-        BOOST_THREAD_DECL bool interruption_enabled();
-        BOOST_THREAD_DECL bool interruption_requested();
+        void BOOST_THREAD_DECL interruption_point();
+        bool BOOST_THREAD_DECL interruption_enabled();
+        bool BOOST_THREAD_DECL interruption_requested();

-        BOOST_THREAD_DECL inline void yield()
+        inline void yield()
        {
            thread::yield();
        }
        
        template<typename TimeDuration>
-        BOOST_THREAD_DECL inline void sleep(TimeDuration const& rel_time)
+        inline void sleep(TimeDuration const& rel_time)
        {
            thread::sleep(get_system_time()+rel_time);
        }
@@ -254,13 +254,13 @@ namespace boost
            }
        };
        
-        BOOST_THREAD_DECL void add_thread_exit_function(thread_exit_function_base*);
+        void add_thread_exit_function(thread_exit_function_base*);
    }
    
    namespace this_thread
    {
        template<typename F>
-        inline void at_thread_exit(F f)
+        void at_thread_exit(F f)
        {
            detail::thread_exit_function_base* const thread_exit_func=new detail::thread_exit_function<F>(f);
            detail::add_thread_exit_function(thread_exit_func);
--- a/include/boost/thread/pthread/timespec.hpp
+++ b/include/boost/thread/pthread/timespec.hpp
@@ -1,10 +1,5 @@
 #ifndef BOOST_THREAD_PTHREAD_TIMESPEC_HPP
 #define BOOST_THREAD_PTHREAD_TIMESPEC_HPP
-//  (C) Copyright 2007 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)

 #include <boost/thread/thread_time.hpp>
 #include <boost/date_time/posix_time/conversion.hpp>
--- a/include/boost/thread/thread_time.hpp
+++ b/include/boost/thread/thread_time.hpp
@@ -1,11 +1,5 @@
 #ifndef BOOST_THREAD_TIME_HPP
 #define BOOST_THREAD_TIME_HPP
-//  (C) Copyright 2007 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)
-
 #include <boost/date_time/microsec_time_clock.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>

--- a/include/boost/thread/win32/basic_timed_mutex.hpp
+++ b/include/boost/thread/win32/basic_timed_mutex.hpp
@@ -59,7 +59,8 @@ namespace boost
            
            void lock()
            {
-                BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
+                bool const success=timed_lock(::boost::detail::get_system_time_sentinel());
+                BOOST_ASSERT(success);
            }
            bool timed_lock(::boost::system_time const& wait_until)
            {
--- a/include/boost/thread/win32/condition_variable.hpp
+++ b/include/boost/thread/win32/condition_variable.hpp
@@ -79,7 +79,8 @@ namespace boost
            {
                if(entry.semaphore)
                {
-                    BOOST_VERIFY(detail::win32::CloseHandle(entry.semaphore));
+                    unsigned long const close_result=detail::win32::CloseHandle(entry.semaphore);
+                    BOOST_ASSERT(close_result);
                    entry.semaphore=0;
                }
                entry.notified=false;
--- a/include/boost/thread/win32/once.hpp
+++ b/include/boost/thread/win32/once.hpp
@@ -40,11 +40,13 @@ namespace boost
            explicit win32_mutex_scoped_lock(void* mutex_handle_):
                mutex_handle(mutex_handle_)
            {
-                BOOST_VERIFY(!win32::WaitForSingleObject(mutex_handle,win32::infinite));
+                unsigned long const res=win32::WaitForSingleObject(mutex_handle,win32::infinite);
+                BOOST_ASSERT(!res);
            }
            ~win32_mutex_scoped_lock()
            {
-                BOOST_VERIFY(win32::ReleaseMutex(mutex_handle)!=0);
+                bool const success=win32::ReleaseMutex(mutex_handle)!=0;
+                BOOST_ASSERT(success);
            }
        };

--- a/include/boost/thread/win32/shared_mutex.hpp
+++ b/include/boost/thread/win32/shared_mutex.hpp
@@ -57,12 +57,14 @@ namespace boost
        {
            if(old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::win32::ReleaseSemaphore(exclusive_sem,1,NULL)!=0);
+                bool const success=detail::win32::ReleaseSemaphore(exclusive_sem,1,NULL)!=0;
+                BOOST_ASSERT(success);
            }
                        
            if(old_state.shared_waiting || old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),NULL)!=0);
+                bool const success=detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),NULL)!=0;
+                BOOST_ASSERT(success);
            }
        }
        
@@ -110,7 +112,8 @@ namespace boost

        void lock_shared()
        {
-            BOOST_VERIFY(timed_lock_shared(::boost::detail::get_system_time_sentinel()));
+            bool const success=timed_lock_shared(::boost::detail::get_system_time_sentinel());
+            BOOST_ASSERT(success);
        }

        bool timed_lock_shared(boost::system_time const& wait_until)
@@ -215,7 +218,8 @@ namespace boost
                    {
                        if(old_state.upgrade)
                        {
-                            BOOST_VERIFY(detail::win32::ReleaseSemaphore(upgrade_sem,1,NULL)!=0);
+                            bool const success=detail::win32::ReleaseSemaphore(upgrade_sem,1,NULL)!=0;
+                            BOOST_ASSERT(success);
                        }
                        else
                        {
@@ -231,7 +235,8 @@ namespace boost

        void lock()
        {
-            BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
+            bool const success=timed_lock(::boost::detail::get_system_time_sentinel());
+            BOOST_ASSERT(success);
        }

        bool timed_lock(boost::system_time const& wait_until)
@@ -359,7 +364,8 @@ namespace boost
                    return;
                }
                    
-                BOOST_VERIFY(!detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite));
+                unsigned long const res=detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite);
+                BOOST_ASSERT(res==0);
            }
        }

@@ -415,7 +421,8 @@ namespace boost
                {
                    if(!last_reader)
                    {
-                        BOOST_VERIFY(!detail::win32::WaitForSingleObject(upgrade_sem,detail::win32::infinite));
+                        unsigned long const res=detail::win32::WaitForSingleObject(upgrade_sem,detail::win32::infinite);
+                        BOOST_ASSERT(res==0);
                    }
                    break;
                }
--- a/include/boost/thread/win32/thread_primitives.hpp
+++ b/include/boost/thread/win32/thread_primitives.hpp
@@ -204,7 +204,8 @@ namespace boost

            inline void release_semaphore(handle semaphore,long count)
            {
-                BOOST_VERIFY(ReleaseSemaphore(semaphore,count,0)!=0);
+                bool const success=ReleaseSemaphore(semaphore,count,0)!=0;
+                BOOST_ASSERT(success);
            }

            class handle_manager
@@ -218,7 +219,8 @@ namespace boost
                {
                    if(handle_to_manage && handle_to_manage!=invalid_handle_value)
                    {
-                        BOOST_VERIFY(CloseHandle(handle_to_manage));
+                        unsigned long const result=CloseHandle(handle_to_manage);
+                        BOOST_ASSERT(result);
                    }
                }
                
--- a/src/pthread/thread.cpp
+++ b/src/pthread/thread.cpp
@@ -55,7 +55,8 @@ namespace boost

            void create_current_thread_tls_key()
            {
-                BOOST_VERIFY(!pthread_key_create(&current_thread_tls_key,NULL));
+                int const res=pthread_key_create(&current_thread_tls_key,NULL);
+                BOOST_ASSERT(!res);
            }
        }
        
@@ -68,7 +69,8 @@ namespace boost
        void set_current_thread_data(detail::thread_data_base* new_data)
        {
            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
-            BOOST_VERIFY(!pthread_setspecific(current_thread_tls_key,new_data));
+            int const res=pthread_setspecific(current_thread_tls_key,new_data);
+            BOOST_ASSERT(!res);
        }
    }
    
@@ -170,7 +172,8 @@ namespace boost
            if(do_join)
            {
                void* result=0;
-                BOOST_VERIFY(!pthread_join(local_thread_info->thread_handle,&result));
+                int const res=pthread_join(local_thread_info->thread_handle,&result);
+                BOOST_ASSERT(!res);
                lock_guard<mutex> lock(local_thread_info->data_mutex);
                local_thread_info->joined=true;
                local_thread_info->done_condition.notify_all();
@@ -217,7 +220,8 @@ namespace boost
            if(do_join)
            {
                void* result=0;
-                BOOST_VERIFY(!pthread_join(local_thread_info->thread_handle,&result));
+                int const res=pthread_join(local_thread_info->thread_handle,&result);
+                BOOST_ASSERT(!res);
                lock_guard<mutex> lock(local_thread_info->data_mutex);
                local_thread_info->joined=true;
                local_thread_info->done_condition.notify_all();
@@ -251,7 +255,8 @@ namespace boost
            lock_guard<mutex> lock(local_thread_info->data_mutex);
            if(!local_thread_info->join_started)
            {
-                BOOST_VERIFY(!pthread_detach(local_thread_info->thread_handle));
+                int const res=pthread_detach(local_thread_info->thread_handle);
+                BOOST_ASSERT(!res);
                local_thread_info->join_started=true;
                local_thread_info->joined=true;
            }
@@ -276,7 +281,9 @@ namespace boost
 #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
                timespec ts;
                to_timespec_duration(xt, ts);
-                BOOST_VERIFY(!pthread_delay_np(&ts));
+                int res = 0;
+                res = pthread_delay_np(&ts);
+                BOOST_ASSERT(res == 0);
 #   elif defined(BOOST_HAS_NANOSLEEP)
                timespec ts;
                to_timespec_duration(xt, ts);
@@ -301,9 +308,13 @@ namespace boost
    void thread::yield()
    {
 #   if defined(BOOST_HAS_SCHED_YIELD)
-        BOOST_VERIFY(!sched_yield());
+        int res = 0;
+        res = sched_yield();
+        BOOST_ASSERT(res == 0);
 #   elif defined(BOOST_HAS_PTHREAD_YIELD)
-        BOOST_VERIFY(!pthread_yield());
+        int res = 0;
+        res = pthread_yield();
+        BOOST_ASSERT(res == 0);
 #   else
        xtime xt;
        xtime_get(&xt, TIME_UTC);
@@ -338,7 +349,8 @@ namespace boost
            local_thread_info->interrupt_requested=true;
            if(local_thread_info->current_cond)
            {
-                BOOST_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond));
+                int const res=pthread_cond_broadcast(local_thread_info->current_cond);
+                BOOST_ASSERT(!res);
            }
        }
    }
--- a/src/pthread/tss.cpp
+++ b/src/pthread/tss.cpp
@@ -17,6 +17,11 @@
 #include <stdexcept>
 #include <cassert>

+#if defined(BOOST_HAS_WINTHREADS)
+#   include <windows.h>
+#   include <boost/thread/detail/tss_hooks.hpp>
+#endif
+
 namespace {

 typedef std::vector<void*> tss_slots;
--- a/src/win32/thread.cpp
+++ b/src/win32/thread.cpp
@@ -58,7 +58,8 @@ namespace boost
        void set_current_thread_data(detail::thread_data_base* new_data)
        {
            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
-            BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));
+            BOOL const res=TlsSetValue(current_thread_tls_key,new_data);
+            BOOST_ASSERT(res);
        }
 #endif

--- a/src/win32/tss_hooks.cpp
+++ b/src/win32/tss_hooks.cpp
@@ -30,7 +30,7 @@
        class CScopedCSLock
        {
        public:
-            CScopedCSLock(LPCRITICAL_SECTION cs) : lk(true), cs(cs) {
+            CScopedCSLock(LPCRITICAL_SECTION cs) : cs(cs), lk(true) {
                ::EnterCriticalSection(cs);
            }
            ~CScopedCSLock() {
--- a/test/test_shared_mutex.cpp
+++ b/test/test_shared_mutex.cpp
@@ -6,7 +6,6 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/condition_variable.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/xtime.hpp>
 #include "util.inl"
@@ -30,19 +29,16 @@ namespace
        unsigned& simultaneous_running_count;
        unsigned& max_simultaneous_running;
        boost::mutex& unblocked_count_mutex;
-        boost::condition_variable& unblocked_condition;
        boost::mutex& finish_mutex;
    public:
        locking_thread(boost::shared_mutex& rw_mutex_,
                       unsigned& unblocked_count_,
                       boost::mutex& unblocked_count_mutex_,
-                       boost::condition_variable& unblocked_condition_,
                       boost::mutex& finish_mutex_,
                       unsigned& simultaneous_running_count_,
                       unsigned& max_simultaneous_running_):
            rw_mutex(rw_mutex_),
            unblocked_count(unblocked_count_),
-            unblocked_condition(unblocked_condition_),
            simultaneous_running_count(simultaneous_running_count_),
            max_simultaneous_running(max_simultaneous_running_),
            unblocked_count_mutex(unblocked_count_mutex_),
@@ -58,7 +54,6 @@ namespace
            {
                boost::mutex::scoped_lock ublock(unblocked_count_mutex);
                ++unblocked_count;
-                unblocked_condition.notify_one();
                ++simultaneous_running_count;
                if(simultaneous_running_count>max_simultaneous_running)
                {
@@ -89,23 +84,15 @@ void test_multiple_readers()
    unsigned simultaneous_running_count=0;
    unsigned max_simultaneous_running=0;
    boost::mutex unblocked_count_mutex;
-    boost::condition_variable unblocked_condition;
    boost::mutex finish_mutex;
    boost::mutex::scoped_lock finish_lock(finish_mutex);
    
    for(unsigned i=0;i<number_of_threads;++i)
    {
-        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                    finish_mutex,simultaneous_running_count,max_simultaneous_running));
+        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_mutex,simultaneous_running_count,max_simultaneous_running));
    }

-    {
-        boost::mutex::scoped_lock lk(unblocked_count_mutex);
-        while(unblocked_count<number_of_threads)
-        {
-            unblocked_condition.wait(lk);
-        }
-    }
+    boost::thread::sleep(delay(1));

    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,number_of_threads);

@@ -127,17 +114,15 @@ void test_only_one_writer_permitted()
    unsigned simultaneous_running_count=0;
    unsigned max_simultaneous_running=0;
    boost::mutex unblocked_count_mutex;
-    boost::condition_variable unblocked_condition;
    boost::mutex finish_mutex;
    boost::mutex::scoped_lock finish_lock(finish_mutex);
    
    for(unsigned i=0;i<number_of_threads;++i)
    {
-        pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                    finish_mutex,simultaneous_running_count,max_simultaneous_running));
+        pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_mutex,simultaneous_running_count,max_simultaneous_running));
    }

-    boost::thread::sleep(delay(2));
+    boost::thread::sleep(delay(1));

    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,1U);

@@ -158,22 +143,13 @@ void test_reader_blocks_writer()
    unsigned simultaneous_running_count=0;
    unsigned max_simultaneous_running=0;
    boost::mutex unblocked_count_mutex;
-    boost::condition_variable unblocked_condition;
    boost::mutex finish_mutex;
    boost::mutex::scoped_lock finish_lock(finish_mutex);
    
-    pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                finish_mutex,simultaneous_running_count,max_simultaneous_running));
-    {
-        boost::mutex::scoped_lock lk(unblocked_count_mutex);
-        while(unblocked_count<1)
-        {
-            unblocked_condition.wait(lk);
-        }
-    }
+    pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    boost::thread::sleep(delay(1));
    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,1U);
-    pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                finish_mutex,simultaneous_running_count,max_simultaneous_running));
+    pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_mutex,simultaneous_running_count,max_simultaneous_running));
    boost::thread::sleep(delay(1));
    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,1U);

@@ -195,7 +171,6 @@ void test_unlocking_writer_unblocks_all_readers()
    unsigned simultaneous_running_count=0;
    unsigned max_simultaneous_running=0;
    boost::mutex unblocked_count_mutex;
-    boost::condition_variable unblocked_condition;
    boost::mutex finish_mutex;
    boost::mutex::scoped_lock finish_lock(finish_mutex);

@@ -203,22 +178,14 @@ void test_unlocking_writer_unblocks_all_readers()

    for(unsigned i=0;i<reader_count;++i)
    {
-        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                    finish_mutex,simultaneous_running_count,max_simultaneous_running));
+        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_mutex,simultaneous_running_count,max_simultaneous_running));
    }
    boost::thread::sleep(delay(1));
    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,0U);

    write_lock.unlock();
    
-    {
-        boost::mutex::scoped_lock lk(unblocked_count_mutex);
-        while(unblocked_count<reader_count)
-        {
-            unblocked_condition.wait(lk);
-        }
-    }
-
+    boost::thread::sleep(delay(1));
    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count);

    finish_lock.unlock();
@@ -237,7 +204,6 @@ void test_unlocking_last_reader_only_unblocks_one_writer()
    unsigned simultaneous_running_writers=0;
    unsigned max_simultaneous_writers=0;
    boost::mutex unblocked_count_mutex;
-    boost::condition_variable unblocked_condition;
    boost::mutex finish_reading_mutex;
    boost::mutex::scoped_lock finish_reading_lock(finish_reading_mutex);
    boost::mutex finish_writing_mutex;
@@ -248,34 +214,18 @@ void test_unlocking_last_reader_only_unblocks_one_writer()

    for(unsigned i=0;i<reader_count;++i)
    {
-        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                    finish_reading_mutex,simultaneous_running_readers,max_simultaneous_readers));
+        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_reading_mutex,simultaneous_running_readers,max_simultaneous_readers));
    }
-    boost::thread::sleep(delay(1));
    for(unsigned i=0;i<writer_count;++i)
    {
-        pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                    finish_writing_mutex,simultaneous_running_writers,max_simultaneous_writers));
+        pool.create_thread(locking_thread<boost::unique_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_writing_mutex,simultaneous_running_writers,max_simultaneous_writers));
    }
-    {
-        boost::mutex::scoped_lock lk(unblocked_count_mutex);
-        while(unblocked_count<reader_count)
-        {
-            unblocked_condition.wait(lk);
-        }
-    }
-    boost::thread::sleep(delay(1));
+    boost::thread::sleep(delay(2));
    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count);

    finish_reading_lock.unlock();

-    {
-        boost::mutex::scoped_lock lk(unblocked_count_mutex);
-        while(unblocked_count<(reader_count+1))
-        {
-            unblocked_condition.wait(lk);
-        }
-    }
+    boost::thread::sleep(delay(2));
    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count+1);

    finish_writing_lock.unlock();
@@ -296,14 +246,12 @@ void test_only_one_upgrade_lock_permitted()
    unsigned simultaneous_running_count=0;
    unsigned max_simultaneous_running=0;
    boost::mutex unblocked_count_mutex;
-    boost::condition_variable unblocked_condition;
    boost::mutex finish_mutex;
    boost::mutex::scoped_lock finish_lock(finish_mutex);
    
    for(unsigned i=0;i<number_of_threads;++i)
    {
-        pool.create_thread(locking_thread<boost::upgrade_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                     finish_mutex,simultaneous_running_count,max_simultaneous_running));
+        pool.create_thread(locking_thread<boost::upgrade_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_mutex,simultaneous_running_count,max_simultaneous_running));
    }

    boost::thread::sleep(delay(1));
@@ -327,7 +275,6 @@ void test_can_lock_upgrade_if_currently_locked_shared()
    unsigned simultaneous_running_count=0;
    unsigned max_simultaneous_running=0;
    boost::mutex unblocked_count_mutex;
-    boost::condition_variable unblocked_condition;
    boost::mutex finish_mutex;
    boost::mutex::scoped_lock finish_lock(finish_mutex);

@@ -335,19 +282,10 @@ void test_can_lock_upgrade_if_currently_locked_shared()

    for(unsigned i=0;i<reader_count;++i)
    {
-        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                    finish_mutex,simultaneous_running_count,max_simultaneous_running));
+        pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_mutex,simultaneous_running_count,max_simultaneous_running));
    }
+    pool.create_thread(locking_thread<boost::upgrade_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,finish_mutex,simultaneous_running_count,max_simultaneous_running));
    boost::thread::sleep(delay(1));
-    pool.create_thread(locking_thread<boost::upgrade_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
-                                                                                 finish_mutex,simultaneous_running_count,max_simultaneous_running));
-    {
-        boost::mutex::scoped_lock lk(unblocked_count_mutex);
-        while(unblocked_count<(reader_count+1))
-        {
-            unblocked_condition.wait(lk);
-        }
-    }
    CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count+1);

    finish_lock.unlock();