diff --git a/build/Jamfile b/build/Jamfile
index 1aec8f19..d1e88ed5 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -31,12 +31,21 @@ subproject libs/thread/build ;
 SEARCH on <module@>threads.jam = $(SUBDIR) ;
 include <module@>threads.jam ;
 
+template thread_libs
+    ## sources ##
+    : <template>thread_base
+    ## requirements ##
+    :
+    ## default build ##
+    : debug release <runtime-link>static/dynamic
+;
+
 #######################
 # Conditionally declare the Boost.Threads dynamic link library boost_threadmon.
 
 if $(NT) && ! $(PTW32)
 {
-    dll boost_threadmon : <template>thread_base ../src/threadmon.cpp ;
+    dll boost_threadmon : <template>thread_libs ../src/threadmon.cpp ;
 }
 
 #######################
@@ -45,7 +54,7 @@ if $(NT) && ! $(PTW32)
 # Base names of the source files for libboost_thread.
 CPP_SOURCES = condition mutex recursive_mutex thread tss xtime once exceptions ;
 
-lib boost_thread : <template>thread_base ../src/$(CPP_SOURCES).cpp ;
+lib boost_thread : <template>thread_libs ../src/$(CPP_SOURCES).cpp ;
 
 #######################
 # Stage the generated targets.
diff --git a/build/threads.jam b/build/threads.jam
index 29bb3841..37f4caa3 100644
--- a/build/threads.jam
+++ b/build/threads.jam
@@ -9,12 +9,12 @@ if $(NT)
     {
         local install-path = $(PTW32[1]) ;
         local lib = $(PTW32[2]) ;
-		pthreads-win32 =
-		      <define>BOOST_HAS_PTHREADS
+        pthreads-win32 =
+              <define>BOOST_HAS_PTHREADS
               <define>PtW32NoCatchWarn
               <include>$(install-path)/pre-built/include
               <library-file>$(install-path)/pre-built/lib/$(lib)
-		;
+        ;
     }
     else
     {
@@ -28,5 +28,5 @@ template thread_base
     ## requirements ##
     : <sysinclude>$(BOOST_ROOT) <threading>multi $(pthreads-win32)
     ## default build ##
-    : debug release <runtime-link>static/dynamic
+    :
 ;
diff --git a/build/threads.mcp b/build/threads.mcp
index 70ed21bf..ba3aaeff 100644
Binary files a/build/threads.mcp and b/build/threads.mcp differ
diff --git a/example/Jamfile b/example/Jamfile
index d339ccb3..924dac6d 100644
--- a/example/Jamfile
+++ b/example/Jamfile
@@ -2,22 +2,6 @@
 #  distribute this software is granted provided this copyright notice appears
 #  in all copies. This software is provided "as is" without express or implied
 #  warranty, and with no claim as to its suitability for any purpose.
-#
-# Boost.Threads build and test Jamfile
-#
-# Declares the following targets:
-#   1. monitor, an example program.
-#   2. starvephil, an example program.
-#   3. tennis, an example program.
-# Additional configuration variables used:
-#   1. PTW32 may be used on Win32 platforms to specify that the pthreads-win32
-#      library should be used instead of "native" threads. This feature is
-#      mostly used for testing and it's generally recommended you use the
-#      native threading libraries instead. PTW32 should be set to be a list
-#      of two strings, the first specifying the installation path of the
-#      pthreads-win32 library and the second specifying which library
-#      variant to link against (see the pthreads-win32 documentation).
-#      Example: jam -sPTW32="c:\pthreads-win32 pthreadVCE.lib"
 
 # Declare the location of this subproject relative to the root.
 subproject libs/thread/example ;
@@ -28,23 +12,23 @@ subproject libs/thread/example ;
 SEARCH on <module@>threads.jam = $(BOOST_ROOT)/libs/thread/build ;
 include <module@>threads.jam ;
 
-template example_base
+template example
     ## sources ##
     : <template>thread_base <lib>../build/boost_thread <lib>../../test/build/unit_test_framework $(threadmon)
     ## requirements ##
     :
     ## default build ##
-    :
+    : release <runtime-link>static
 ;
 
-exe monitor : <template>example_base monitor.cpp ;
-exe starvephil : <template>example_base starvephil.cpp ;
-exe tennis : <template>example_base tennis.cpp ;
-exe condition : <template>example_base condition.cpp ;
-exe mutex : <template>example_base mutex.cpp ;
-exe once : <template>example_base once.cpp ;
-exe recursive_mutex : <template>example_base recursive_mutex.cpp ;
-exe thread : <template>example_base thread.cpp ;
-exe thread_group : <template>example_base thread_group.cpp ;
-exe tss : <template>example_base tss.cpp ;
-exe xtime : <template>example_base xtime.cpp ;
+exe monitor : <template>example monitor.cpp ;
+exe starvephil : <template>example starvephil.cpp ;
+exe tennis : <template>example tennis.cpp ;
+exe condition : <template>example condition.cpp ;
+exe mutex : <template>example mutex.cpp ;
+exe once : <template>example once.cpp ;
+exe recursive_mutex : <template>example recursive_mutex.cpp ;
+exe thread : <template>example thread.cpp ;
+exe thread_group : <template>example thread_group.cpp ;
+exe tss : <template>example tss.cpp ;
+exe xtime : <template>example xtime.cpp ;
diff --git a/example/mutex.cpp b/example/mutex.cpp
index 5c6705bb..c05ce169 100644
--- a/example/mutex.cpp
+++ b/example/mutex.cpp
@@ -8,7 +8,7 @@ class counter
 {
 public:
     counter() : count(0) { }
-   
+
     int increment() {
         boost::mutex::scoped_lock scoped_lock(mutex);
         return ++count;
@@ -34,8 +34,8 @@ int main(int, char*[])
     boost::thread_group thrds;
     for (int i=0; i < num_threads; ++i)
         thrds.create_thread(&change_count);
-      
+
     thrds.join_all();
-   
+
     return 0;
 }
diff --git a/example/recursive_mutex.cpp b/example/recursive_mutex.cpp
index 5588f2fd..6aba75f3 100644
--- a/example/recursive_mutex.cpp
+++ b/example/recursive_mutex.cpp
@@ -11,7 +11,7 @@ public:
         boost::recursive_mutex::scoped_lock scoped_lock(mutex);
         count += val;
         return count;
-    }   
+    }
     int increment() {
         boost::recursive_mutex::scoped_lock scoped_lock(mutex);
         return add(1);
@@ -33,11 +33,11 @@ int main(int, char*[])
 {
     const int num_threads=4;
 
-    boost::thread_group threads;   
+    boost::thread_group threads;
     for (int i=0; i < num_threads; ++i)
         threads.create_thread(&change_count);
-      
+
     threads.join_all();
-   
+
     return 0;
 }
diff --git a/src/condition.cpp b/src/condition.cpp
index 0f5948a1..9099f47e 100644
--- a/src/condition.cpp
+++ b/src/condition.cpp
@@ -244,28 +244,28 @@ void condition::do_wait()
 
 bool condition::do_timed_wait(const xtime& xt)
 {
-	bool ret = false;
+    bool ret = false;
     unsigned int res = 0;
 
-	for (;;)
-	{
-		int milliseconds;
-		to_duration(xt, milliseconds);
+    for (;;)
+    {
+        int milliseconds;
+        to_duration(xt, milliseconds);
 
-		res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), milliseconds);
-		assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
-		ret = (res == WAIT_OBJECT_0);
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue), milliseconds);
+        assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
+        ret = (res == WAIT_OBJECT_0);
 
-		if (res == WAIT_TIMEOUT)
-		{
-			xtime cur;
-			xtime_get(&cur, TIME_UTC);
-			if (xtime_cmp(xt, cur) > 0)
-				continue;
-		}
+        if (res == WAIT_TIMEOUT)
+        {
+            xtime cur;
+            xtime_get(&cur, TIME_UTC);
+            if (xtime_cmp(xt, cur) > 0)
+                continue;
+        }
 
-		break;
-	}
+        break;
+    }
 
     unsigned was_waiting=0;
     unsigned was_gone=0;
diff --git a/src/mac/safe.cpp b/src/mac/safe.cpp
index 32260354..cc858a81 100644
--- a/src/mac/safe.cpp
+++ b/src/mac/safe.cpp
@@ -72,7 +72,7 @@ OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Durati
             if(lDuration != kDurationImmediate && lDuration != kDurationForever)
             {
                 sExpiration = AddDurationToAbsolute(lDuration, UpTime());
-            }            
+            }
             lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, lDuration);
             assert(lStatus == noErr || lStatus == kMPTimeoutErr);
             if(lStatus == noErr)
@@ -92,7 +92,7 @@ OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Durati
                     // no time left
                         lDuration = kDurationImmediate;
                     }
-                }            
+                }
             // if we entered the critical region, exit it again
                 lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
                 assert(lStatus == noErr);
diff --git a/src/mutex.cpp b/src/mutex.cpp
index 46ac92aa..f1cb21bb 100644
--- a/src/mutex.cpp
+++ b/src/mutex.cpp
@@ -145,25 +145,25 @@ bool timed_mutex::do_trylock()
 
 bool timed_mutex::do_timedlock(const xtime& xt)
 {
-	unsigned int res = 0;
-	for (;;)
-	{
-		int milliseconds;
-		to_duration(xt, milliseconds);
+    unsigned int res = 0;
+    for (;;)
+    {
+        int milliseconds;
+        to_duration(xt, milliseconds);
 
-		res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
-		assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
+        assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
 
-		if (res == WAIT_TIMEOUT)
-		{
-			xtime cur;
-			xtime_get(&cur, TIME_UTC);
-			if (xtime_cmp(xt, cur) > 0)
-				continue;
-		}
+        if (res == WAIT_TIMEOUT)
+        {
+            xtime cur;
+            xtime_get(&cur, TIME_UTC);
+            if (xtime_cmp(xt, cur) > 0)
+                continue;
+        }
 
-		return res == WAIT_OBJECT_0;
-	}
+        return res == WAIT_OBJECT_0;
+    }
 }
 
 void timed_mutex::do_unlock()
diff --git a/src/once.cpp b/src/once.cpp
index fabcae33..cdfcebf6 100644
--- a/src/once.cpp
+++ b/src/once.cpp
@@ -60,50 +60,50 @@ static void do_once()
 }
 #elif defined(BOOST_HAS_MPTASKS)
 namespace {
-	void *remote_call_proxy(void *pData)
-	{
-		std::pair<void (*)(), boost::once_flag *> &rData(*reinterpret_cast<std::pair<void (*)(), boost::once_flag *> *>(pData));
+    void *remote_call_proxy(void *pData)
+    {
+        std::pair<void (*)(), boost::once_flag *> &rData(*reinterpret_cast<std::pair<void (*)(), boost::once_flag *> *>(pData));
 
-		if(*rData.second == false)
-		{
-			rData.first();
-			*rData.second = true;
-		}
+        if(*rData.second == false)
+        {
+            rData.first();
+            *rData.second = true;
+        }
 
-		return(NULL);
-	}
+        return(NULL);
+    }
 }
 #elif defined(BOOST_HAS_WINTHREADS)
 namespace {
-	// The signature for InterlockedCompareExchange has changed with the
-	// addition of Win64 support. I can't determine any (consistent and
-	// portable) way of using conditional compilation to detect this, so
-	// we use these type wrappers.  Unfortunately, the various vendors
-	// use different calling conventions and other signature anamolies,
-	// and thus have unique types as well.  This is known to work on VC6,
-	// VC7, Borland 5.5.2 and gcc 3.2.  Are there other signatures for
-	// other platforms?
-	inline LONG ice_wrapper(LONG (__stdcall *ice)(LONG*, LONG, LONG), volatile LONG* dest, LONG exch, LONG cmp)
-	{
-		return (*ice)(const_cast<LONG*>(dest), exch, cmp);
-	}
+    // The signature for InterlockedCompareExchange has changed with the
+    // addition of Win64 support. I can't determine any (consistent and
+    // portable) way of using conditional compilation to detect this, so
+    // we use these type wrappers.  Unfortunately, the various vendors
+    // use different calling conventions and other signature anamolies,
+    // and thus have unique types as well.  This is known to work on VC6,
+    // VC7, Borland 5.5.2 and gcc 3.2.  Are there other signatures for
+    // other platforms?
+    inline LONG ice_wrapper(LONG (__stdcall *ice)(LONG*, LONG, LONG), volatile LONG* dest, LONG exch, LONG cmp)
+    {
+        return (*ice)(const_cast<LONG*>(dest), exch, cmp);
+    }
 
-	inline LONG ice_wrapper(LONG (__stdcall *ice)(volatile LONG*, LONG, LONG), volatile LONG* dest, LONG exch, LONG cmp)
-	{
-		return (*ice)(dest, exch, cmp);
-	}
+    inline LONG ice_wrapper(LONG (__stdcall *ice)(volatile LONG*, LONG, LONG), volatile LONG* dest, LONG exch, LONG cmp)
+    {
+        return (*ice)(dest, exch, cmp);
+    }
 
-	inline LONG ice_wrapper(LPVOID (__stdcall *ice)(LPVOID*, LPVOID, LPVOID), volatile LONG* dest, LONG exch, LONG cmp)
-	{
-		return (LONG)(*ice)((LPVOID*)dest, (LPVOID)exch, (LPVOID)cmp);
-	}
+    inline LONG ice_wrapper(LPVOID (__stdcall *ice)(LPVOID*, LPVOID, LPVOID), volatile LONG* dest, LONG exch, LONG cmp)
+    {
+        return (LONG)(*ice)((LPVOID*)dest, (LPVOID)exch, (LPVOID)cmp);
+    }
 
-	// The friendly form of InterlockedCompareExchange that defers
-	// according to the above function type wrappers.
-	inline LONG compare_exchange(volatile LPLONG dest, LONG exch, LONG cmp)
-	{
-		return ice_wrapper(&InterlockedCompareExchange, dest, exch, cmp);
-	}
+    // The friendly form of InterlockedCompareExchange that defers
+    // according to the above function type wrappers.
+    inline LONG compare_exchange(volatile LPLONG dest, LONG exch, LONG cmp)
+    {
+        return ice_wrapper(&InterlockedCompareExchange, dest, exch, cmp);
+    }
 }
 #endif
 
@@ -112,7 +112,7 @@ namespace boost {
 void call_once(void (*func)(), once_flag& flag)
 {
 #if defined(BOOST_HAS_WINTHREADS)
-	if (compare_exchange(&flag, 1, 1) == 0)
+    if (compare_exchange(&flag, 1, 1) == 0)
     {
 #if defined(BOOST_NO_STRINGSTREAM)
         std::ostrstream strm;
@@ -130,10 +130,10 @@ void call_once(void (*func)(), once_flag& flag)
         res = WaitForSingleObject(mutex, INFINITE);
         assert(res == WAIT_OBJECT_0);
 
-		if (compare_exchange(&flag, 1, 1) == 0)
+        if (compare_exchange(&flag, 1, 1) == 0)
         {
             func();
-			InterlockedExchange(&flag, 1);
+            InterlockedExchange(&flag, 1);
         }
 
         res = ReleaseMutex(mutex);
diff --git a/src/recursive_mutex.cpp b/src/recursive_mutex.cpp
index 851c09a8..6ab84eeb 100644
--- a/src/recursive_mutex.cpp
+++ b/src/recursive_mutex.cpp
@@ -195,35 +195,35 @@ bool recursive_timed_mutex::do_trylock()
 
 bool recursive_timed_mutex::do_timedlock(const xtime& xt)
 {
-	for (;;)
-	{
-		int milliseconds;
-		to_duration(xt, milliseconds);
+    for (;;)
+    {
+        int milliseconds;
+        to_duration(xt, milliseconds);
 
-		unsigned int res = 0;
-		res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
-		assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
+        unsigned int res = 0;
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
+        assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
 
-		if (res == WAIT_TIMEOUT)
-		{
-			xtime cur;
-			xtime_get(&cur, TIME_UTC);
-			if (xtime_cmp(xt, cur) > 0)
-				continue;
-		}
+        if (res == WAIT_TIMEOUT)
+        {
+            xtime cur;
+            xtime_get(&cur, TIME_UTC);
+            if (xtime_cmp(xt, cur) > 0)
+                continue;
+        }
 
-		if (res == WAIT_OBJECT_0)
-		{
-			if (++m_count > 1)
-			{
-				res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-				assert(res);
-			}
-			return true;
-		}
+        if (res == WAIT_OBJECT_0)
+        {
+            if (++m_count > 1)
+            {
+                res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
+                assert(res);
+            }
+            return true;
+        }
 
-		return false;
-	}
+        return false;
+    }
 }
 
 void recursive_timed_mutex::do_unlock()
diff --git a/src/thread.cpp b/src/thread.cpp
index cd39f553..a1f7e8ea 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -191,44 +191,44 @@ void thread::join()
 
 void thread::sleep(const xtime& xt)
 {
-	for (int foo=0; foo < 5; ++foo)
-	{
+    for (int foo=0; foo < 5; ++foo)
+    {
 #if defined(BOOST_HAS_WINTHREADS)
-		int milliseconds;
-		to_duration(xt, milliseconds);
-		Sleep(milliseconds);
+        int milliseconds;
+        to_duration(xt, milliseconds);
+        Sleep(milliseconds);
 #elif defined(BOOST_HAS_PTHREADS)
 #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
-		timespec ts;
-		to_timespec_duration(xt, ts);
-		int res = 0;
-		res = pthread_delay_np(&ts);
-		assert(res == 0);
+        timespec ts;
+        to_timespec_duration(xt, ts);
+        int res = 0;
+        res = pthread_delay_np(&ts);
+        assert(res == 0);
 #   elif defined(BOOST_HAS_NANOSLEEP)
-		timespec ts;
-		to_timespec_duration(xt, ts);
+        timespec ts;
+        to_timespec_duration(xt, ts);
 
-		//  nanosleep takes a timespec that is an offset, not
-		//  an absolute time.
-		nanosleep(&ts, 0);
+        //  nanosleep takes a timespec that is an offset, not
+        //  an absolute time.
+        nanosleep(&ts, 0);
 #   else
-		mutex mx;
-		mutex::scoped_lock lock(mx);
-		condition cond;
-		cond.timed_wait(lock, xt);
+        mutex mx;
+        mutex::scoped_lock lock(mx);
+        condition cond;
+        cond.timed_wait(lock, xt);
 #   endif
 #elif defined(BOOST_HAS_MPTASKS)
-		int microseconds;
-		to_microduration(xt, microseconds);
-		Duration lMicroseconds(kDurationMicrosecond * microseconds);
-		AbsoluteTime sWakeTime(DurationToAbsolute(lMicroseconds));
-		threads::mac::detail::safe_delay_until(&sWakeTime);
+        int microseconds;
+        to_microduration(xt, microseconds);
+        Duration lMicroseconds(kDurationMicrosecond * microseconds);
+        AbsoluteTime sWakeTime(DurationToAbsolute(lMicroseconds));
+        threads::mac::detail::safe_delay_until(&sWakeTime);
 #endif
-		xtime cur;
-		xtime_get(&cur, TIME_UTC);
-		if (xtime_cmp(xt, cur) <= 0)
-			return;
-	}
+        xtime cur;
+        xtime_get(&cur, TIME_UTC);
+        if (xtime_cmp(xt, cur) <= 0)
+            return;
+    }
 }
 
 void thread::yield()
diff --git a/src/timeconv.inl b/src/timeconv.inl
index e2d6c403..508971ef 100644
--- a/src/timeconv.inl
+++ b/src/timeconv.inl
@@ -59,7 +59,7 @@ namespace {
         res = boost::xtime_get(&cur, boost::TIME_UTC);
         assert(res == boost::TIME_UTC);
 
-		if (boost::xtime_cmp(xt, cur) <= 0)
+        if (boost::xtime_cmp(xt, cur) <= 0)
         {
             ts.tv_sec = 0;
             ts.tv_nsec = 0;
@@ -90,7 +90,7 @@ namespace {
         res = boost::xtime_get(&cur, boost::TIME_UTC);
         assert(res == boost::TIME_UTC);
 
-		if (boost::xtime_cmp(xt, cur) <= 0)
+        if (boost::xtime_cmp(xt, cur) <= 0)
             milliseconds = 0;
         else
         {
@@ -107,7 +107,7 @@ namespace {
         res = boost::xtime_get(&cur, boost::TIME_UTC);
         assert(res == boost::TIME_UTC);
 
-		if (boost::xtime_get(&cur, boost::TIME_UTC) <= 0)
+        if (boost::xtime_get(&cur, boost::TIME_UTC) <= 0)
             microseconds = 0;
         else
         {
diff --git a/test/Jamfile b/test/Jamfile
index 5d0f52cd..f6b2ebab 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -32,21 +32,21 @@ include testing.jam ;
 
 sources = test.cpp test_thread.cpp test_mutex.cpp test_condition.cpp test_tss.cpp test_once.cpp ;
 
-template test_base
+template test
     ## sources ##
     : <template>thread_base <lib>../build/boost_thread <lib>../../test/build/unit_test_framework $(threadmon)
     ## requirements ##
     :
     ## default build ##
-    :
+    : debug release <runtime-link>static/dynamic
 ;
 
 #######################
 # Declare the Boost.Threads unit test program test_thread.
 
-run test_thread.cpp <template>test_base ;
-run test_mutex.cpp <template>test_base  ;
-run test_condition.cpp <template>test_base ;
-run test_tss.cpp <template>test_base ;
-run test_once.cpp <template>test_base ;
-run test_xtime.cpp <template>test_base ;
\ No newline at end of file
+run test_thread.cpp <template>test ;
+run test_mutex.cpp <template>test  ;
+run test_condition.cpp <template>test ;
+run test_tss.cpp <template>test ;
+run test_once.cpp <template>test ;
+run test_xtime.cpp <template>test ;
diff --git a/test/test.mcp b/test/test.mcp
index e391a34f..f27f0b97 100644
Binary files a/test/test.mcp and b/test/test.mcp differ
diff --git a/test/test_condition.cpp b/test/test_condition.cpp
index b5080705..7516504d 100644
--- a/test/test_condition.cpp
+++ b/test/test_condition.cpp
@@ -6,91 +6,91 @@
 
 namespace
 {
-	struct condition_test_data
-	{
-		condition_test_data() : notified(0), awoken(0) { }
+    struct condition_test_data
+    {
+        condition_test_data() : notified(0), awoken(0) { }
 
-		boost::mutex mutex;
-		boost::condition condition;
-		int notified;
-		int awoken;
-	};
+        boost::mutex mutex;
+        boost::condition condition;
+        int notified;
+        int awoken;
+    };
 
-	void condition_test_thread(void* param)
-	{
-		condition_test_data* data = static_cast<condition_test_data*>(param);
-		boost::mutex::scoped_lock lock(data->mutex);
-		BOOST_CHECK(lock ? true : false);
-		while (!(data->notified > 0))
-			data->condition.wait(lock);
-		BOOST_CHECK(lock ? true : false);
-		data->awoken++;
-	}
+    void condition_test_thread(void* param)
+    {
+        condition_test_data* data = static_cast<condition_test_data*>(param);
+        boost::mutex::scoped_lock lock(data->mutex);
+        BOOST_CHECK(lock ? true : false);
+        while (!(data->notified > 0))
+            data->condition.wait(lock);
+        BOOST_CHECK(lock ? true : false);
+        data->awoken++;
+    }
 
-	class thread_adapter
-	{
-	public:
-		thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
-		void operator()() const { _func(_param); }
-	private:
-		void (*_func)(void*);
-		void* _param;
-	};
+    class thread_adapter
+    {
+    public:
+        thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
+        void operator()() const { _func(_param); }
+    private:
+        void (*_func)(void*);
+        void* _param;
+    };
 
-	struct cond_predicate
-	{
-		cond_predicate(int& var, int val) : _var(var), _val(val) { }
+    struct cond_predicate
+    {
+        cond_predicate(int& var, int val) : _var(var), _val(val) { }
 
-		bool operator()() { return _var == _val; }
+        bool operator()() { return _var == _val; }
 
-		int& _var;
-		int _val;
-	};
+        int& _var;
+        int _val;
+    };
 
-	void condition_test_waits(void* param)
-	{
-		condition_test_data* data = static_cast<condition_test_data*>(param);
+    void condition_test_waits(void* param)
+    {
+        condition_test_data* data = static_cast<condition_test_data*>(param);
 
-		boost::mutex::scoped_lock lock(data->mutex);
-		BOOST_CHECK(lock ? true : false);
+        boost::mutex::scoped_lock lock(data->mutex);
+        BOOST_CHECK(lock ? true : false);
 
-		// Test wait.
-		while (data->notified != 1)
-			data->condition.wait(lock);
-		BOOST_CHECK(lock ? true : false);
-		BOOST_CHECK_EQUAL(data->notified, 1);
-		data->awoken++;
-		data->condition.notify_one();
+        // Test wait.
+        while (data->notified != 1)
+            data->condition.wait(lock);
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data->notified, 1);
+        data->awoken++;
+        data->condition.notify_one();
 
-		// Test predicate wait.
-		data->condition.wait(lock, cond_predicate(data->notified, 2));
-		BOOST_CHECK(lock ? true : false);
-		BOOST_CHECK_EQUAL(data->notified, 2);
-		data->awoken++;
-		data->condition.notify_one();
+        // Test predicate wait.
+        data->condition.wait(lock, cond_predicate(data->notified, 2));
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data->notified, 2);
+        data->awoken++;
+        data->condition.notify_one();
 
-		// Test timed_wait.
-		boost::xtime xt;
-		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-		xt.sec += 10;
-		while (data->notified != 3)
-			data->condition.timed_wait(lock, xt);
-		BOOST_CHECK(lock ? true : false);
-		BOOST_CHECK_EQUAL(data->notified, 3);
-		data->awoken++;
-		data->condition.notify_one();
+        // Test timed_wait.
+        boost::xtime xt;
+        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+        xt.sec += 10;
+        while (data->notified != 3)
+            data->condition.timed_wait(lock, xt);
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data->notified, 3);
+        data->awoken++;
+        data->condition.notify_one();
 
-		// Test predicate timed_wait.
-		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-		xt.sec += 10;
-		cond_predicate pred(data->notified, 4);
-		BOOST_CHECK(data->condition.timed_wait(lock, xt, pred));
-		BOOST_CHECK(lock ? true : false);
-		BOOST_CHECK(pred());
-		BOOST_CHECK_EQUAL(data->notified, 4);
-		data->awoken++;
-		data->condition.notify_one();
-	}
+        // Test predicate timed_wait.
+        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+        xt.sec += 10;
+        cond_predicate pred(data->notified, 4);
+        BOOST_CHECK(data->condition.timed_wait(lock, xt, pred));
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK(pred());
+        BOOST_CHECK_EQUAL(data->notified, 4);
+        data->awoken++;
+        data->condition.notify_one();
+    }
 }
 
 void test_condition_notify_one()
@@ -101,7 +101,7 @@ void test_condition_notify_one()
 
     {
         boost::mutex::scoped_lock lock(data.mutex);
-		BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK(lock ? true : false);
         data.notified++;
         data.condition.notify_one();
     }
@@ -121,7 +121,7 @@ void test_condition_notify_all()
 
     {
         boost::mutex::scoped_lock lock(data.mutex);
-		BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK(lock ? true : false);
         data.notified++;
         data.condition.notify_all();
     }
@@ -140,7 +140,7 @@ void test_condition_waits()
 
     {
         boost::mutex::scoped_lock lock(data.mutex);
-		BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK(lock ? true : false);
 
         BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
         xt.sec += 1;
@@ -149,7 +149,7 @@ void test_condition_waits()
         data.condition.notify_one();
         while (data.awoken != 1)
             data.condition.wait(lock);
-		BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK(lock ? true : false);
         BOOST_CHECK_EQUAL(data.awoken, 1);
 
         BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
@@ -159,7 +159,7 @@ void test_condition_waits()
         data.condition.notify_one();
         while (data.awoken != 2)
             data.condition.wait(lock);
-		BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK(lock ? true : false);
         BOOST_CHECK_EQUAL(data.awoken, 2);
 
         BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
@@ -169,19 +169,19 @@ void test_condition_waits()
         data.condition.notify_one();
         while (data.awoken != 3)
             data.condition.wait(lock);
-		BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK(lock ? true : false);
         BOOST_CHECK_EQUAL(data.awoken, 3);
 
-		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-		xt.sec += 1;
-		boost::thread::sleep(xt);
-		data.notified++;
-		data.condition.notify_one();
-		while (data.awoken != 4)
-			data.condition.wait(lock);
-		BOOST_CHECK(lock ? true : false);
-		BOOST_CHECK_EQUAL(data.awoken, 4);
-	}
+        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+        xt.sec += 1;
+        boost::thread::sleep(xt);
+        data.notified++;
+        data.condition.notify_one();
+        while (data.awoken != 4)
+            data.condition.wait(lock);
+        BOOST_CHECK(lock ? true : false);
+        BOOST_CHECK_EQUAL(data.awoken, 4);
+    }
 
     BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
     xt.sec += 1;
@@ -192,11 +192,11 @@ void test_condition_waits()
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: condition test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: condition test suite");
 
-	test->add(BOOST_TEST_CASE(&test_condition_notify_one));
-	test->add(BOOST_TEST_CASE(&test_condition_notify_all));
-	test->add(BOOST_TEST_CASE(&test_condition_waits));
+    test->add(BOOST_TEST_CASE(&test_condition_notify_one));
+    test->add(BOOST_TEST_CASE(&test_condition_notify_all));
+    test->add(BOOST_TEST_CASE(&test_condition_waits));
 
-	return test;
+    return test;
 }
diff --git a/test/test_mutex.cpp b/test/test_mutex.cpp
index 242a1cf6..cf37028f 100644
--- a/test/test_mutex.cpp
+++ b/test/test_mutex.cpp
@@ -8,57 +8,57 @@
 
 namespace
 {
-	inline bool xtime_in_range(boost::xtime& xt, int less_seconds, int greater_seconds)
-	{
-		boost::xtime cur;
-		BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
+    inline bool xtime_in_range(boost::xtime& xt, int less_seconds, int greater_seconds)
+    {
+        boost::xtime cur;
+        BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
 
-		boost::xtime less = cur;
-		less.sec += less_seconds;
+        boost::xtime less = cur;
+        less.sec += less_seconds;
 
-		boost::xtime greater = cur;
-		greater.sec += greater_seconds;
+        boost::xtime greater = cur;
+        greater.sec += greater_seconds;
 
-		return (boost::xtime_cmp(xt, less) >= 0) && (boost::xtime_cmp(xt, greater) <= 0);
-	}
+        return (boost::xtime_cmp(xt, less) >= 0) && (boost::xtime_cmp(xt, greater) <= 0);
+    }
 }
 
 template <typename M>
 struct test_lock
 {
-	typedef M mutex_type;
-	typedef typename M::scoped_lock lock_type;
+    typedef M mutex_type;
+    typedef typename M::scoped_lock lock_type;
 
-	void operator()()
-	{
-		mutex_type mutex;
-		boost::condition condition;
+    void operator()()
+    {
+        mutex_type mutex;
+        boost::condition condition;
 
-		// Test the lock's constructors.
-		{
-			lock_type lock(mutex, false);
-			BOOST_CHECK(!lock);
-		}
-		lock_type lock(mutex);
-		BOOST_CHECK(lock ? true : false);
+        // Test the lock's constructors.
+        {
+            lock_type lock(mutex, false);
+            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;
-		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-		xt.nsec += 100000000;
+        // Construct and initialize an xtime for a fast time out.
+        boost::xtime xt;
+        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+        xt.nsec += 100000000;
 
-		// 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 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);
-	}
+        // Test the lock and unlock methods.
+        lock.unlock();
+        BOOST_CHECK(!lock);
+        lock.lock();
+        BOOST_CHECK(lock ? true : false);
+    }
 };
 
 template <typename M>
@@ -67,44 +67,44 @@ struct test_trylock
     typedef M mutex_type;
     typedef typename M::scoped_try_lock try_lock_type;
 
-	void operator()()
-	{
-		mutex_type mutex;
-		boost::condition condition;
+    void operator()()
+    {
+        mutex_type mutex;
+        boost::condition condition;
 
-		// Test the lock's constructors.
-		{
-			try_lock_type lock(mutex);
-			BOOST_CHECK(lock ? true : false);
-		}
-		{
-			try_lock_type lock(mutex, false);
-			BOOST_CHECK(!lock);
-		}
-		try_lock_type lock(mutex, true);
-		BOOST_CHECK(lock ? true : false);
+        // Test the lock's constructors.
+        {
+            try_lock_type lock(mutex);
+            BOOST_CHECK(lock ? true : false);
+        }
+        {
+            try_lock_type lock(mutex, false);
+            BOOST_CHECK(!lock);
+        }
+        try_lock_type lock(mutex, true);
+        BOOST_CHECK(lock ? true : false);
 
-		// Construct and initialize an xtime for a fast time out.
-		boost::xtime xt;
-		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-		xt.nsec += 100000000;
+        // Construct and initialize an xtime for a fast time out.
+        boost::xtime xt;
+        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+        xt.nsec += 100000000;
 
-		// 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 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);
-	}
+        // 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 M>
@@ -113,52 +113,52 @@ struct test_timedlock
     typedef M mutex_type;
     typedef typename M::scoped_timed_lock timed_lock_type;
 
-	void operator()()
-	{
-		mutex_type mutex;
-		boost::condition condition;
+    void operator()()
+    {
+        mutex_type mutex;
+        boost::condition condition;
 
-		// Test the lock's constructors.
-		{
-			// Construct and initialize an xtime for a fast time out.
-			boost::xtime xt;
-			BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-			xt.nsec += 100000000;
+        // Test the lock's constructors.
+        {
+            // Construct and initialize an xtime for a fast time out.
+            boost::xtime xt;
+            BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+            xt.nsec += 100000000;
 
-			timed_lock_type lock(mutex, xt);
-			BOOST_CHECK(lock ? true : false);
-		}
-		{
-			timed_lock_type lock(mutex, false);
-			BOOST_CHECK(!lock);
-		}
-		timed_lock_type lock(mutex, true);
-		BOOST_CHECK(lock ? true : false);
+            timed_lock_type lock(mutex, xt);
+            BOOST_CHECK(lock ? true : false);
+        }
+        {
+            timed_lock_type lock(mutex, false);
+            BOOST_CHECK(!lock);
+        }
+        timed_lock_type lock(mutex, true);
+        BOOST_CHECK(lock ? true : false);
 
-		// Construct and initialize an xtime for a fast time out.
-		boost::xtime xt;
-		BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-		xt.nsec += 100000000;
+        // Construct and initialize an xtime for a fast time out.
+        boost::xtime xt;
+        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+        xt.nsec += 100000000;
 
-		// 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);
-		BOOST_CHECK(xtime_in_range(xt, -1, 0));
+        // 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);
+        BOOST_CHECK(xtime_in_range(xt, -1, 0));
 
-		// 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_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-		xt.nsec += 100000000;
-		BOOST_CHECK(lock.timed_lock(xt));
-		BOOST_CHECK(lock ? true : false);
-	}
+        // 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_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+        xt.nsec += 100000000;
+        BOOST_CHECK(lock.timed_lock(xt));
+        BOOST_CHECK(lock ? true : false);
+    }
 };
 
 template <typename M>
@@ -167,63 +167,63 @@ struct test_recursive_lock
     typedef M mutex_type;
     typedef typename M::scoped_lock lock_type;
 
-	void operator()()
-	{
-		mutex_type mx;
-		lock_type lock1(mx);
-		lock_type lock2(mx);
-	}
+    void operator()()
+    {
+        mutex_type mx;
+        lock_type lock1(mx);
+        lock_type lock2(mx);
+    }
 };
 
 void test_mutex()
 {
-	test_lock<boost::mutex>()();
+    test_lock<boost::mutex>()();
 }
 
 void test_try_mutex()
 {
-	test_lock<boost::try_mutex>()();
-	test_trylock<boost::try_mutex>()();
+    test_lock<boost::try_mutex>()();
+    test_trylock<boost::try_mutex>()();
 }
 
 void test_timed_mutex()
 {
-	test_lock<boost::timed_mutex>()();
-	test_trylock<boost::timed_mutex>()();
-	test_timedlock<boost::timed_mutex>()();
+    test_lock<boost::timed_mutex>()();
+    test_trylock<boost::timed_mutex>()();
+    test_timedlock<boost::timed_mutex>()();
 }
 
 void test_recursive_mutex()
 {
-	test_lock<boost::recursive_mutex>()();
-	test_recursive_lock<boost::recursive_mutex>()();
+    test_lock<boost::recursive_mutex>()();
+    test_recursive_lock<boost::recursive_mutex>()();
 }
 
 void test_recursive_try_mutex()
 {
-	test_lock<boost::recursive_try_mutex>()();
-	test_trylock<boost::recursive_try_mutex>()();
-	test_recursive_lock<boost::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_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>()();
+    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>()();
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: mutex test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: mutex test suite");
 
-	test->add(BOOST_TEST_CASE(&test_mutex));
-	test->add(BOOST_TEST_CASE(&test_try_mutex));
-	test->add(BOOST_TEST_CASE(&test_timed_mutex));
-	test->add(BOOST_TEST_CASE(&test_recursive_mutex));
-	test->add(BOOST_TEST_CASE(&test_recursive_try_mutex));
-	test->add(BOOST_TEST_CASE(&test_recursive_timed_mutex));
+    test->add(BOOST_TEST_CASE(&test_mutex));
+    test->add(BOOST_TEST_CASE(&test_try_mutex));
+    test->add(BOOST_TEST_CASE(&test_timed_mutex));
+    test->add(BOOST_TEST_CASE(&test_recursive_mutex));
+    test->add(BOOST_TEST_CASE(&test_recursive_try_mutex));
+    test->add(BOOST_TEST_CASE(&test_recursive_timed_mutex));
 
-	return test;
+    return test;
 }
diff --git a/test/test_once.cpp b/test/test_once.cpp
index bb42a0a0..1d4bb08d 100644
--- a/test/test_once.cpp
+++ b/test/test_once.cpp
@@ -5,35 +5,35 @@
 
 namespace
 {
-	int once_value = 0;
-	boost::once_flag once = BOOST_ONCE_INIT;
+    int once_value = 0;
+    boost::once_flag once = BOOST_ONCE_INIT;
 
-	void init_once_value()
-	{
-		once_value++;
-	}
+    void init_once_value()
+    {
+        once_value++;
+    }
 
-	void test_once_thread()
-	{
-		boost::call_once(init_once_value, once);
-	}
+    void test_once_thread()
+    {
+        boost::call_once(init_once_value, once);
+    }
 }
 
 void test_once()
 {
-	const int NUMTHREADS=5;
-	boost::thread_group threads;
-	for (int i=0; i<NUMTHREADS; ++i)
-		threads.create_thread(&test_once_thread);
-	threads.join_all();
-	BOOST_CHECK_EQUAL(once_value, 1);
+    const int NUMTHREADS=5;
+    boost::thread_group threads;
+    for (int i=0; i<NUMTHREADS; ++i)
+        threads.create_thread(&test_once_thread);
+    threads.join_all();
+    BOOST_CHECK_EQUAL(once_value, 1);
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: once test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: once test suite");
 
-	test->add(BOOST_TEST_CASE(test_once));
+    test->add(BOOST_TEST_CASE(test_once));
 
-	return test;
+    return test;
 }
diff --git a/test/test_thread.cpp b/test/test_thread.cpp
index 1197a541..a620180b 100644
--- a/test/test_thread.cpp
+++ b/test/test_thread.cpp
@@ -5,85 +5,85 @@
 
 namespace
 {
-	inline bool xtime_in_range(boost::xtime& xt, int less_seconds, int greater_seconds)
-	{
-		boost::xtime cur;
-		BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
+    inline bool xtime_in_range(boost::xtime& xt, int less_seconds, int greater_seconds)
+    {
+        boost::xtime cur;
+        BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
 
-		boost::xtime less = cur;
-		less.sec += less_seconds;
+        boost::xtime less = cur;
+        less.sec += less_seconds;
 
-		boost::xtime greater = cur;
-		greater.sec += greater_seconds;
+        boost::xtime greater = cur;
+        greater.sec += greater_seconds;
 
-		return (boost::xtime_cmp(xt, less) >= 0) && (boost::xtime_cmp(xt, greater) <= 0);
-	}
+        return (boost::xtime_cmp(xt, less) >= 0) && (boost::xtime_cmp(xt, greater) <= 0);
+    }
 
-	int test_value;
+    int test_value;
 
-	void simple_thread()
-	{
-		test_value = 999;
-	}
+    void simple_thread()
+    {
+        test_value = 999;
+    }
 
-	struct thread_adapter
-	{
-		thread_adapter(void (*func)(boost::thread& parent), boost::thread& parent)
-			: func(func), parent(parent)
-		{
-		}
+    struct thread_adapter
+    {
+        thread_adapter(void (*func)(boost::thread& parent), boost::thread& parent)
+            : func(func), parent(parent)
+        {
+        }
 
-		void operator()()
-		{
-			(*func)(parent);
-		}
+        void operator()()
+        {
+            (*func)(parent);
+        }
 
-		void (*func)(boost::thread& parent);
-		boost::thread& parent;
-	};
+        void (*func)(boost::thread& parent);
+        boost::thread& parent;
+    };
 
-	void comparison_thread(boost::thread& parent)
-	{
-		boost::thread thrd;
-		BOOST_TEST(thrd != parent);
-		BOOST_TEST(thrd == boost::thread());
-	}
+    void comparison_thread(boost::thread& parent)
+    {
+        boost::thread thrd;
+        BOOST_TEST(thrd != parent);
+        BOOST_TEST(thrd == boost::thread());
+    }
 }
 
 void test_sleep()
 {
-	boost::xtime xt;
-	BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
-	xt.sec += 3;
-	
-	boost::thread::sleep(xt);
+    boost::xtime xt;
+    BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC), boost::TIME_UTC);
+    xt.sec += 3;
 
-	// Insure it's in a range instead of checking actual equality due to time lapse
-	BOOST_CHECK(xtime_in_range(xt, -1, 0));
+    boost::thread::sleep(xt);
+
+    // Insure it's in a range instead of checking actual equality due to time lapse
+    BOOST_CHECK(xtime_in_range(xt, -1, 0));
 }
 
 void test_creation()
 {
-	test_value = 0;
-	boost::thread thrd(&simple_thread);
-	thrd.join();
-	BOOST_CHECK_EQUAL(test_value, 999);
+    test_value = 0;
+    boost::thread thrd(&simple_thread);
+    thrd.join();
+    BOOST_CHECK_EQUAL(test_value, 999);
 }
 
 void test_comparison()
 {
-	boost::thread self;
-	boost::thread thrd(thread_adapter(comparison_thread, self));
-	thrd.join();
+    boost::thread self;
+    boost::thread thrd(thread_adapter(comparison_thread, self));
+    thrd.join();
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: thread test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: thread test suite");
 
     test->add(BOOST_TEST_CASE(test_sleep));
-	test->add(BOOST_TEST_CASE(test_creation));
-	test->add(BOOST_TEST_CASE(test_comparison));
+    test->add(BOOST_TEST_CASE(test_creation));
+    test->add(BOOST_TEST_CASE(test_comparison));
 
     return test;
 }
diff --git a/test/test_tss.cpp b/test/test_tss.cpp
index 53f63136..ccb4ff62 100644
--- a/test/test_tss.cpp
+++ b/test/test_tss.cpp
@@ -6,37 +6,37 @@
 
 namespace
 {
-	boost::mutex tss_mutex;
-	int tss_instances = 0;
+    boost::mutex tss_mutex;
+    int tss_instances = 0;
 
-	struct tss_value_t
-	{
-		tss_value_t()
-		{
-			boost::mutex::scoped_lock lock(tss_mutex);
-			++tss_instances;
-			value = 0;
-		}
-		~tss_value_t()
-		{
-			boost::mutex::scoped_lock lock(tss_mutex);
-			--tss_instances;
-		}
-		int value;
-	};
+    struct tss_value_t
+    {
+        tss_value_t()
+        {
+            boost::mutex::scoped_lock lock(tss_mutex);
+            ++tss_instances;
+            value = 0;
+        }
+        ~tss_value_t()
+        {
+            boost::mutex::scoped_lock lock(tss_mutex);
+            --tss_instances;
+        }
+        int value;
+    };
 
-	boost::thread_specific_ptr<tss_value_t> tss_value;
+    boost::thread_specific_ptr<tss_value_t> tss_value;
 
-	void test_tss_thread()
-	{
-		tss_value.reset(new tss_value_t());
-		for (int i=0; i<1000; ++i)
-		{
-			int& n = tss_value->value;
-			BOOST_CHECK_EQUAL(n, i);
-			++n;
-		}
-	}
+    void test_tss_thread()
+    {
+        tss_value.reset(new tss_value_t());
+        for (int i=0; i<1000; ++i)
+        {
+            int& n = tss_value->value;
+            BOOST_CHECK_EQUAL(n, i);
+            ++n;
+        }
+    }
 }
 
 void test_tss()
@@ -51,9 +51,9 @@ void test_tss()
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: tss test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: tss test suite");
 
-	test->add(BOOST_TEST_CASE(test_tss));
+    test->add(BOOST_TEST_CASE(test_tss));
 
-	return test;
+    return test;
 }
diff --git a/test/test_xtime.cpp b/test/test_xtime.cpp
index 6dba3ab1..dc3c0eb7 100644
--- a/test/test_xtime.cpp
+++ b/test/test_xtime.cpp
@@ -4,47 +4,47 @@
 
 void test_xtime_cmp()
 {
-	boost::xtime xt1, xt2, cur;
-	BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
+    boost::xtime xt1, xt2, cur;
+    BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
 
-	xt1 = xt2 = cur;
-	xt1.nsec -= 1;
-	xt2.nsec += 1;
+    xt1 = xt2 = cur;
+    xt1.nsec -= 1;
+    xt2.nsec += 1;
 
-	BOOST_CHECK(boost::xtime_cmp(xt1, cur) < 0);
-	BOOST_CHECK(boost::xtime_cmp(xt2, cur) > 0);
-	BOOST_CHECK(boost::xtime_cmp(cur, cur) == 0);
+    BOOST_CHECK(boost::xtime_cmp(xt1, cur) < 0);
+    BOOST_CHECK(boost::xtime_cmp(xt2, cur) > 0);
+    BOOST_CHECK(boost::xtime_cmp(cur, cur) == 0);
 
-	xt1 = xt2 = cur;
-	xt1.sec -= 1;
-	xt2.sec += 1;
+    xt1 = xt2 = cur;
+    xt1.sec -= 1;
+    xt2.sec += 1;
 
-	BOOST_CHECK(boost::xtime_cmp(xt1, cur) < 0);
-	BOOST_CHECK(boost::xtime_cmp(xt2, cur) > 0);
-	BOOST_CHECK(boost::xtime_cmp(cur, cur) == 0);
+    BOOST_CHECK(boost::xtime_cmp(xt1, cur) < 0);
+    BOOST_CHECK(boost::xtime_cmp(xt2, cur) > 0);
+    BOOST_CHECK(boost::xtime_cmp(cur, cur) == 0);
 }
 
 void test_xtime_get()
 {
-	boost::xtime orig, cur, old;
-	BOOST_CHECK_EQUAL(boost::xtime_get(&orig, boost::TIME_UTC), boost::TIME_UTC);
-	old = orig;
+    boost::xtime orig, cur, old;
+    BOOST_CHECK_EQUAL(boost::xtime_get(&orig, boost::TIME_UTC), boost::TIME_UTC);
+    old = orig;
 
-	for (int x=0; x < 100; ++x)
-	{
-		BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
-		BOOST_CHECK(boost::xtime_cmp(cur, orig) >= 0);
-		BOOST_CHECK(boost::xtime_cmp(cur, old) >= 0);
-		old = cur;
-	}
+    for (int x=0; x < 100; ++x)
+    {
+        BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), boost::TIME_UTC);
+        BOOST_CHECK(boost::xtime_cmp(cur, orig) >= 0);
+        BOOST_CHECK(boost::xtime_cmp(cur, old) >= 0);
+        old = cur;
+    }
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-	boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: xtime test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: xtime test suite");
 
-	test->add(BOOST_TEST_CASE(&test_xtime_cmp));
-	test->add(BOOST_TEST_CASE(&test_xtime_get));
+    test->add(BOOST_TEST_CASE(&test_xtime_cmp));
+    test->add(BOOST_TEST_CASE(&test_xtime_get));
 
-	return test;
+    return test;
 }
diff --git a/tutorial/Jamfile b/tutorial/Jamfile
new file mode 100644
index 00000000..ad1451d9
--- /dev/null
+++ b/tutorial/Jamfile
@@ -0,0 +1,30 @@
+#  (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+#
+
+# Declare the location of this subproject relative to the root.
+
+subproject libs/thread/tutorial ;
+
+# Include threads.jam for Boost.Threads global build information.
+# This greatly simplifies the Jam code needed to configure the build
+# for the various Win32 build types.
+SEARCH on <module@>threads.jam = $(BOOST_ROOT)/libs/thread/build ;
+include <module@>threads.jam ;
+
+template tutorial
+    ## sources ##
+    : <template>thread_base <lib>../build/boost_thread <lib>../../test/build/unit_test_framework $(threadmon)
+    ## requirements ##
+    :
+    ## default build ##
+    : release <runtime-link>static
+;
+
+exe helloworld : <template>tutorial helloworld.cpp ;
+exe helloworld2 : <template>tutorial helloworld2.cpp ;
+exe helloworld3 : <template>tutorial helloworld3.cpp ;
+exe factorial : <template>tutorial factorial.cpp ;
+exe factorial2 : <template>tutorial factorial2.cpp ;
diff --git a/tutorial/factorial.cpp b/tutorial/factorial.cpp
new file mode 100644
index 00000000..08ca06dc
--- /dev/null
+++ b/tutorial/factorial.cpp
@@ -0,0 +1,26 @@
+#include <boost/thread/thread.hpp>
+#include <iostream>
+
+class factorial
+{
+public:
+    factorial(int x, int& res) : x(x), res(res) { }
+    void operator()() { res = calculate(x); }
+    int result() const { return res; }
+
+private:
+    int calculate(int x) { return x <= 1 ? 1 : x * calculate(x-1); }
+
+private:
+    int x;
+    int& res;
+};
+
+int main()
+{
+    int result;
+    factorial f(10, result);
+    boost::thread thrd(f);
+    thrd.join();
+    std::cout << "10! = " << result << std::endl;
+}
\ No newline at end of file
diff --git a/tutorial/factorial2.cpp b/tutorial/factorial2.cpp
new file mode 100644
index 00000000..47376c6f
--- /dev/null
+++ b/tutorial/factorial2.cpp
@@ -0,0 +1,26 @@
+#include <boost/thread/thread.hpp>
+#include <boost/ref.hpp>
+#include <iostream>
+
+class factorial
+{
+public:
+    factorial(int x) : x(x), res(0) { }
+    void operator()() { res = calculate(x); }
+    int result() const { return res; }
+
+private:
+    int calculate(int x) { return x <= 1 ? 1 : x * calculate(x-1); }
+
+private:
+    int x;
+    int res;
+};
+
+int main()
+{
+    factorial f(10);
+    boost::thread thrd(boost::ref(f));
+    thrd.join();
+    std::cout << "10! = " << f.result() << std::endl;
+}
\ No newline at end of file
diff --git a/tutorial/helloworld.cpp b/tutorial/helloworld.cpp
new file mode 100644
index 00000000..fdf29675
--- /dev/null
+++ b/tutorial/helloworld.cpp
@@ -0,0 +1,13 @@
+#include <boost/thread/thread.hpp>
+#include <iostream>
+
+void helloworld()
+{
+    std::cout << "Hello World!" << std::endl;
+}
+
+int main()
+{
+    boost::thread thrd(&helloworld);
+    thrd.join();
+}
\ No newline at end of file
diff --git a/tutorial/helloworld2.cpp b/tutorial/helloworld2.cpp
new file mode 100644
index 00000000..85874da1
--- /dev/null
+++ b/tutorial/helloworld2.cpp
@@ -0,0 +1,15 @@
+#include <boost/thread/thread.hpp>
+#include <iostream>
+
+struct helloworld
+{
+    helloworld(const char* who) : m_who(who) { }
+    void operator()() { std::cout << m_who << "says, \"Hello World.\"" << std::endl; }
+    const char* m_who;
+};
+
+int main()
+{
+    boost::thread thrd(helloworld("Bob"));
+    thrd.join();
+}
\ No newline at end of file
diff --git a/tutorial/helloworld3.cpp b/tutorial/helloworld3.cpp
new file mode 100644
index 00000000..20628323
--- /dev/null
+++ b/tutorial/helloworld3.cpp
@@ -0,0 +1,14 @@
+#include <boost/thread/thread.hpp>
+#include <boost/bind.hpp>
+#include <iostream>
+
+void helloworld(const char* who)
+{
+    std::cout << who << "says, \"Hello World.\"" << std::endl;
+}
+
+int main()
+{
+    boost::thread thrd(boost::bind(&helloworld, "Bob"));
+    thrd.join();
+}
\ No newline at end of file