From cfce0892e038d7e13aaee0f1ade0adfa454d4eb6 Mon Sep 17 00:00:00 2001
From: "William E. Kempf" <wekempf@cox.net>
Date: Fri, 6 Sep 2002 15:34:48 +0000
Subject: [PATCH] Added tutorial sources. Changed tabs to spaces.

[SVN r15179]
---
 build/Jamfile               |  13 +-
 build/threads.jam           |   8 +-
 build/threads.mcp           | Bin 91726 -> 5727 bytes
 example/Jamfile             |  42 ++----
 example/mutex.cpp           |   6 +-
 example/recursive_mutex.cpp |   8 +-
 src/condition.cpp           |  34 ++---
 src/mac/safe.cpp            |   4 +-
 src/mutex.cpp               |  32 ++--
 src/once.cpp                |  78 +++++-----
 src/recursive_mutex.cpp     |  50 +++----
 src/thread.cpp              |  58 ++++----
 src/timeconv.inl            |   6 +-
 test/Jamfile                |  16 +-
 test/test.mcp               | Bin 53600 -> 3675 bytes
 test/test_condition.cpp     | 188 ++++++++++++------------
 test/test_mutex.cpp         | 284 ++++++++++++++++++------------------
 test/test_once.cpp          |  38 ++---
 test/test_thread.cpp        | 102 ++++++-------
 test/test_tss.cpp           |  62 ++++----
 test/test_xtime.cpp         |  56 +++----
 tutorial/Jamfile            |  30 ++++
 tutorial/factorial.cpp      |  26 ++++
 tutorial/factorial2.cpp     |  26 ++++
 tutorial/helloworld.cpp     |  13 ++
 tutorial/helloworld2.cpp    |  15 ++
 tutorial/helloworld3.cpp    |  14 ++
 27 files changed, 663 insertions(+), 546 deletions(-)
 create mode 100644 tutorial/Jamfile
 create mode 100644 tutorial/factorial.cpp
 create mode 100644 tutorial/factorial2.cpp
 create mode 100644 tutorial/helloworld.cpp
 create mode 100644 tutorial/helloworld2.cpp
 create mode 100644 tutorial/helloworld3.cpp

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 70ed21bffcdf4eacac6f353cb47ba2bb5a031860..ba3aaeff3e809f5e7b588a09ca12b52a095c0fe9 100644
GIT binary patch
delta 23
fcmX?ihV{PA1TiKBg^l7BqAUsu3JQ}ah@J)jVDJZT

literal 91726
zcmYe!&(C3CU|?ooVANn>jNxNoj5T9m;FMrsU`S+SVq|~;=lqn^@Wi5`%={vSfTH}Y
z)Z`MF)QF&+6N{4a^Av(hQWTuEwH2K6^NRCxQmukgbMs456<ku2O4Au|sBtVU$=5AO
zEJ{x;!KEZ1F*!RiJ+(+7ATcjB2bZeg{L-T2RE3bD)YM{JY8;c3Q;Ulg0uoCyaH;{j
z7GzscX<kWYZYnObLcnfT2u>|2$;?Z~X`EYTPO5@$VnG2uMNXxeIVlRR6(vQ9I1Pfk
z3t}-YXE~P^m*nRvc&ApD=NF~mG|kMyTLF}6-Ba^$nFLbel3AQsT%4Mll#^P7Pn~;C
zeo|tNf`36tW^QH`eziWCdD-|?z_JjIB;%|PNo2VNnRuK9Q5Bw8l!q_mo!xxREWB}f
z%`GGVf1>kBEK5{y&d<$F%u7-5$;`u<TEGf@67$ka6Vvf4@(uEGEGPh{2;89rHqO7a
zq@WaMt^q3{5RxD@F8RsuG7Cq5`z9v)2P^od7Nw`+4-SZn6x?zWac78t0B1re52S>c
zlm}8rY{~<v#h>y(Dgs>HaHR#XG_-8T5l#UC&W^>o_=6}YwF;DAAW0V*JqqAL!Y8vB
zXJmpbhh|p=-^An$U4MMegs1?eM?4t~WF%A}{t_iTGcO1fW%#pOg@qZRXay-DCR#!2
zTq}}O3raHc^FXCFo>CvAme?c!Qj0$cfK))^1ZVhy^9-m)OV7+pXK>2TFD}sw$tX%q
zOtC_#f>2~oDjpOWc(D$vZct<)F@vaNP$a>r241zGNP&wFScQTj1Gf)iG^z(sDr^*O
z$kjB81bTggDv4TBW08ZG&nR-31rCZdN-={XgVt0)l|w3ca7n;27lu4ay2X&iNP!qC
zpy>`n9GU|ONMnmDQ2qrKR~SaZ5-_?1qG&>qK`D@sWr}g9=VB|I3A)${p2D!D=wd5~
zU$7_XVk_Kfy4VV5qDHb4VmeByE=FyKqIwZmx-PcDm#~YiAgv4Md}yJFYA8e!Ytk;Z
z!k@N_t#BspVk<nUyVwep9-vhOn)i`pu%&N^R-6eOB8@kNLzG}i!w?DFX&gl!Yt(_<
zj-JXPy09g4unhKe4oU?`H7`npL3${7k~>rZ?nDn&fIsO&6+!%oBLhIy;K>G16}U44
zQ~}&A5c^Qm1XK;q^1c|V0B81q%Hz!>Fg3U<0hl%TG7Qud0@((t3U}s#D!`Y8U`lY*
z6EMeuk|Z>vVa-lR#^BCWNQ&@hEhL55G8mFHo@|Dx3QwW{`41z@A(?<R<00g6WIw0^
zl-g!QjE#(Xax?@+NC?0NL{%6V7?_}bc883gf_b?N3=Aw_76ZdX1_lOJD0?dd0|OhB
zeV2iOfgQqT1gYhKvNahP7&xJ9Uj_ySE+`u`(8>*E&t_m?;DNIDF)%RjLfOw47#R2<
zY$hQF1_pj8+k}CEK>*4QXJB9ugtBWH7#Kk6K;Br)z`!636+g(pz#sx;KVo2D5QVUr
zLH3J5*#-;@4B}9B6axbTXsj3%1Rygdq2db}7#O6W>=O(O4AM~cM+OE483>yNWVS4n
zZNb36AO~e9FfcI4L)kqH3=9fT_BsXz21O|QECU0B5|sUcfq_98!e#}z9TYd9pa+?$
z3KjQaU|>*#vO(dg4rR|}U|`UIvX3z^Fo5C!r1uR21A`VsoDCF~+EBJR0|SE&l%34L
zz@Q6d_cJgs=t0>V85kJ!q3kOR3=E*~0!9BX1_lO0h&VgQokmbLNS`s3?Zd#p0E#nE
z63Jv>U@(P>w=gg;m_ga|7#J8p?f|LT&A`9_@+XLWm4Si55~}7M0|SE<gv|kpJ8LK#
z<Zl}&+nIrZ!4}F+VqjpfgR*NF7#QrK>=_IU3=U8>$X||7_C*E;1}7-{Jp%&+$ShFu
z1*I<+h&U%GEM1{&4+aJXHz+%ufq?;(XF%#fc7fzT?5PY444zOm>lqjrKyd~VKgqzr
z;0+aj!oa`)3L}vCe+C8yP(A@=6;RsogQ(#G`OhE9j$mM52!OJS85kG>p=?mz41%)P
zFfcF#L)oA-5CUa`><Wdjxk33p49W)C1<Fed3=G_$Fay~EVn;GCFn}<KUB<w`0LmL6
z_5=n7hG?i>P#DHQ*%ufX7-FI9&kPI<aS%2SD1XO8*`Txr$`7Dy5At^+R2&pvAPf=*
zg&`;{g4oj;7#LEZYBn)2Fr-4+ml+rs(xB`w3=9mQH~<wNp!}Kv5$6S^1yGs;iG%FV
zf{HgVFfe38*-IE07(nwyAT>uB7#Kk19f<vufq@|pqJ|GthUG)qAomwQ*`PQngtAK+
z7#ND6>}d=P44}9H6=6FW7#KkL6U4sBz`y`f2P@7%VG3e{@^m>wFFz>GE1+zUTPmUK
z$qWn(RZup_%xWkblt)0}1v2L=0|Nu7%mNjWpt7wFq6Q}k%DbSv2FjD5yamcrp!^2P
z$Dq6k%D14j2MR|}x&Y-NP~HLM8BksU<q=Tc0Obi#UI66*P}&FOWl*{Yl@p+H02F7S
zFb2g1C`>_N3Gy2#{y=d8iZ4)@g2ECMhM=$mg&8QUKw$(58&H^l!U7ZqAisnB42naL
ze?jR36#t++1<C`Ucmbt(P+AA&15i2x<rz@eg3>%Ft%K4yC~bq%G$<{D(l99Pg3>G~
zt$@-fC~bn$Bq)!8(jzGUg7PP*`~jtDP+bM8qd?^;sNMtRDNx-9s-HmR2B<y))p?*g
z6O@KPbtI@>0+p4Zx&jnOpn3;X-+<CBsD1&}E1-H9RNjK>6;Rp$)hVDn3aUduWj?6P
z1Jxm*x&vBgfa?opP@xPh|3PIHsJsW2^Pn^fD%U~fGPEuMrwNdoVBrc17f=|%%m;-J
zEUZCp2E{SR-=MGt#TzJ2LE#9CACNy_?gxbd%q=i`LFobHN08q^{spBGP}&2fH&EIG
z#StiMVc`yo8&DX5;scaMK=BPqN1${8N<Xl)ge~oW(iJGZfx;4$mO*J86c?a)0i^>_
zdI7~NC?H^Q2Z|?9ItGOsDEvTi3`*aybOB4>pnL+#7ohk7#SJLFVR-}=Pss5Ds>?y?
z1QhnLbO}mNu>1r{N1%8H<wsDS1Epb5x&`GgP#OZIXIP#Cr9n_S2c;iSJ_Y43P<;<d
zFQEJeO0Tf=3`%dHv<XWCAipAGP#$VvU|{>lzyOLe1`r=2&(gri6xbon6u375)G7oe
zY>)(~KxtrL5HN?fsX%;?I0FMi10w_LSy1H-ZbpJNfCx4QhI&x7hDq{)q(LQB3TR+H
zzMv>IEwe%|qW~0{P&2_4BLgEN0~j+vb%2Cf86f~7h9m)!WOo*y0E!a^28IjllNY^V
zcNSd$;WIk0JA+a)NEHLa|Nji~Ai2hft&Z!&Kp13IMoMuu*iw+Spd<!LG6D<?T(AEB
z|NozXfm@J)feDlaLBS46(n26JRzsSf0ssF$xWVqsz`zfhb8yZ9&BPY#WhE9t>}N0l
zxrc$3kul0MK*2XW3Y6s-7#JlSUNbO&l6u1b{||StJ4+~l)w6=uD=<R*2qhVqKq;C5
zEC_NS)a#(o00k0Q9O64L304fs;|%3s0}$$<?N(5E0}2sPz67Neki8%egVG%+U4qgr
zC?A0GKFCCneW3gT$}6DuKPZiX5)UXJfYKz$6QHsHl*d7V11e)c`3~d|P?-QKBXH#r
zQ2qer16UaZ3Sdw^1m#Cq8iti8u=EbfGq8LB$~&NZ4$AN7<qIs&!tyD|FW~$K@(?4W
zEdg?41t?HKl3>gN4z%hWg{uxSFr<OXKCtj8G2%j?oQVOP79bvnq>Gvzg{#i||9={k
zHX-7p<VXtva2WzBIG8|X2s@|(K~5-S21k5+aY<qks0~b}0TgQkmHD6q4=Nrp45QR>
zjG$nG1R99MFdwG?2LmH`bVK3){|BI+2v{MsTIL0fM`3SlFoNoHMg|56Mg|5+Mg|5c
zMg|6HMg|5MMg|61Mg|6XMg|52Mg|5&Mg|5YMg|6DMg|5IMg|5|Mg|5oMg|6TMg|5g
zMg|6LMg|6bMg|50Mg|5$Mg|5WMg|5GMg|5mMg|6RMg|58Mg|5;Mg|5eMg|54Mg|5)
zMg|5aMg|5KMg|5~Mg|5qMg|6VMg|5?Mg|5iMg|6NMg|5SMg|67Mg|5yMg|6dMh1oe
zMh1pJMh1ppMh1ouMh1pZMh1p3Mh1p(Mh1omMh1pRMh1o`Mh1pxMh1o$Mh1phMh1pB
zMh1p>Mh1oiM$jTh28JX?28Lut28I+y28L8n<>njg16t*$7ZBjA=aZSl0OCWZdSOBy
zsX00M;rT^5DSF8T(3KQ=MPQZAdXU94aIL|f{-F`bf)II-$rVto=nD%OtP=I|OG_Ah
zGLsZMa|`l|N)!SDoEe-Fb8_<Y^AtQ%a|#%I!xbR2N+6k_)G7wZ;v9wuXMZ<0WL*KS
zC|t-qQ$T<-Z21hzq7IZ9K==$B)b|XKNfpG*9@;D(@*+RDUWgtB^ocZx+u`%e5H5U1
z8D*LaZAuH|bm;UH$j=HWb5I~jjQJ*zAargC#01U#fNAJrCrH34Ko(!3%->j{E%;P`
zL>+@wNornRW-$YV(n~HVV8|^kNrkk?AuNzs1!#FCSQf$pwbzsL^HMTF>wduE2p&kT
z1iZ=yECFSLM2i#CQXyiA#o0NjWvMx6Jh&ndBQr0v1l%zIGeE9LNzKVDOD(F5&rQq&
z>qHR%=}9SxFGwxQ%umToPJ|eaDgsiIUlO03pI4GvQ35sti3^fN(~iUi$rgc^$;Kxq
z=H!4J0b1$`HUyhENPRJedr(EdYBKZEb5cw4^T3|XOD!*sPs~e+Pf5*5ElDi~8xQJE
z6hWNp8|)MBn3EF^i9c}G%!eq-F9sWsoDW{n8=sjE)>>Q=U!0tgno^pRT7)S8vOfh~
z1&RPjMJ_0}CPQ^67L}zIWMo1@*9uf6K==%~`FWWo`A|!e^9xc_;**OqOF%IZUzD1j
znGcDxV(d~Ndx}z%ON)v#%TnVJDGyx?q|ORz70N_8gB3KT<zyx?q*kORmx9tJN>pQt
zf=nwZhJ+u82J!Rrk|C)S%m9g`<rgKV#wRBhL(*d^e8C$yNRYT7#qgYhlqMiCla!g4
z0*)dOBR)4RJ~<h|g|c%~bK}$UU@~c?dC4GOfR({G@g=Fb1v!Z&si>k!iN&ZQ1}O4|
zC_Ez+o-qo~1chgc!ZSnRnWOM5P<WOoJVS_MP?mC_#2$3Up1}%531lW(4-})Q5)dIs
zgcs|AhZ0bPz#MQZVU$3$OF^A{Si=i6I0fpMgTe>YnFe+4L2S^V9H^5IVuJ>pK%IRM
z8#F)%>hy!ypg}fJ=O4rd4a|W$`yh5RXa)nsU|?YA0?ime*)u^S`cU>V&?q~Uy%{t*
z4rOl#jbuaFpb0^cTS46Oh{-;Ndx*(C2GC>;XaEDG<_}`Bj}hb+(0~L30|O&y&;c|s
z0b+v&6F>tLAU0?K5;RZ&VuJ=aK?4>bHfZ1&qzA+X4RnGANkHrp=%5LR4e}#s&;!H<
zO^AR7H9+k7h{-<2)riSH#yyD1K1R@F6LjE~@eX3Lj}bIM0~!PYnFE>x1Pz9O*nbg|
zeN3Ri6wv4sXrdEj25683#0L2bG*|*+g9brBd=MMdL4kHqnLvZEpuu2}IB0+oG?)Tn
zg9bQ3gTo*;Xpj{&xB_B>2HXum0n5O^1e&k|r4NueXmSuV=mKJcCe%QKkRUcFPC<h(
zAodo-WFOOB#AF{6XhI4!I0I4xic?S=fY=WZlYLB}NmWq#15Lt$(k5u|2E+!%Curam
z#0G^EXfOxF2H6jqpa8K!6B8gmgV>+}UT8Og88jFS8bk$&HzFqcm?tA9`<Rz9Fff1y
zd_ihJX%dtsKy1*2FKA#G#0E_~fd+y>Y|tb%Xu<=;ev6pwV+Kt~fd*<pbLSxUgYplE
z4H{$v4RnLpptuDMc!SuW0V~j;G>8o{8#LexVuJ>PAtQtgETG8<kbgkppuumD9Ec5y
zBT!s|*i#r77(fHeAU0^i5tNQW?86KU44?si5c@g<0|RK_9>fNPIcT6C#0I$^H0Tau
z|3pmov4RE#K?BO5No0_lK@%k)HYn|Y(hZ0WN^hWv6A&8|51;{i5F6wdP<a7jgX{<S
z0mKI7DbPSQhz-h9puunu8#b8(V)r2?`&dDffS^eSkT@uffd=nEY|w-tXkq}wKES}h
z0E%M}8#I{?Dw{y;$B4;3R?q|)sGI`LlYrs{6pkP^XuuOR(hFjPCRsoeR3J9UkI?aG
zHc%P_O;CZvLHP(YQ3Yay!V)xL1!9Bz1@aGw4H5%QRDjr^^ah$J0kJ`41!zJG#0E`#
zg9m3B7}!950mUUq{4`>+j}27TfhN2_;-Gwi7^H_}OyWpTH=ZxZ-yfPfAeva+gF>On
zi-DH~)EEIJWH(PAP+v71N{2z|2q+zjq=}CM))oO3=1>JuP&yh)$3W>=C>;l-<Dql{
zlum@wNl-c&N~b{SR4APWr6Z9X!odb<0)Q5NK&7>yv^JCufYO0b+8;?fCv$EhC=GHW
ziE*)|q?RORf|3g_REq?ZmW0w$P+A&F%Rp&aC@l}A6`-^tly-sAu25PDN-INYPblpL
zrB$G`Dw6Yf1agaW6pB&{auSnMb5rw5K<SMYs?ZEdTS93oC~X3zgQ2uJl(vA<Ay8Tk
zN~=R@2Po|brG25aACz{3((X{&2}<ijX#*(j4W)gcv>}u>D$mSIVPIhX%AjU_gyBE~
zCzSt<LCyLNV?u)s18la43+Fr$BuRq?dI-%H!DdxJgHQ~hi~-gP8Y5!hU;+z(W=S9>
zfofmSi~x9E1+JEXfq?@o4>N+3fq@k=z5zCi9Kzn--rg}Fz=wf>u^|Ffn2}=$k{*zG
zNL(yTM$kG4EaGGf;h36&wJ6cdg@qkV7<EbyLlbh~!?cXjq=mr14=Xb;f_7$;=IT+^
zqai@m5D*0yJ&5iwRSh3CY%~OhPza1xt3xQVMx8nu0;3^7lMq1kH%5Gk2o3-yKFFaa
zIho0cpqVGkKnE*>3#0Pj!lR7Q5EwBbFq#KOOjM70bdZL?XdWD-5i{y6x`)7MUZ8uB
zk6JiLLtr#74AO`hbr#)2fCY1VBDxz;w<kijhoY+)<wKVPf|dt@mLP(bcY&5mftD<S
zmJ|*DJ(Osr>Tub3%LqRY1~N$qib&9UG0<jM5Y4lrban0j|8GERPf>CKY*8(W;3#Kg
zg}~@0K%(NC>`j0~nNC|pObiSXObiT?ObiTCObiUtObiS%ObiUNObiV2ObiSPObiT)
zObiT4ObiUlObiSvObiUFObiTaObiU_ObiTKObiU#ObiVAObiSLObiT$ObiT0ObiSr
zObiTWObiU>ObiSbObiT`ObiTGObiSTObiT;ObiT8ObiSzObiUJObiTeObiU}ObiU3
zObiTOObiU(ObiS@ObiUZObiTuObiVEObiSGObiTxObiUcObiSmObiU6ObiTRObiU+
zObiSWObiT>ObiTBObiUsObiS$ObiUMObiThObiV1ObiSOObiT(ObiT3ObiUkObiSu
zObiUE;7zWBY-=dmzDsLH1_m2O1_oP31_nDu1_paB(2_nLM$pk>pnVJYw~#V`4+|3p
z9eM%YO8~0QL5GHcN`24?4WQNcpvnQVGeQEi<&=SeK@v(!L1}5|(Pc8w<I-e7P5>VW
z1~Eq-Dy{$(SA^0^&|}n;p$#q-C|?!o9yKUUa^eQp)2NjbNC<=>J{&$}7O8u4ow4lC
z^<ZF!FH-}B5hT1}J6#~WQ4$&glNY@q`al!ZBnUMCg#y(IpryF5U^j$jB@{)YoRJj*
z;f_I|bGj(=G%Q6?X3D7U(GVEwAuyT~hI$N+x}VYz0ObJ?rqrC_ub&yZ8w%=E-(XMZ
zwpggZC^h0jAfu$Dz)D{~E3qt5uedZ%FF8L~zn~~Tr8K#uSU)QzTi;O6P(LL<xmZ83
zAQQTod{_k%q#Hl1yfo^W(GVC70Ww2?i-7^-5Hd228r3!$0z)wbu$<S#kOMjpV<>ut
z95*vEFhb9)AxHP9o?#XO;6qgSpa)!VL1|7X%@3sopfop>=0Q5)gNe`4FW6JTCo`!i
zu_!YYbiM~OR2eIjW`xpgNZOcreG`*WbTL6y!Dw~`8(+eT7~qB$DX=e`BLG^|0y@r$
zee<O^(CI2jjIn`+>mkfhl7WHaOd9BjAJEZ50$f{9L64t;gbc^&ThQZ>KqrVm#4t%{
zNTcY)R7F?>Y7SwA_*LLMB?OlPsbnvHSHWb-7{dW;LG1T~nS`Lh3K%#*Hyt1Zp)8!C
z0hPx>fv$o;2oo^C0eTk$LIdoIEAYX`NW!#YLVS-fo$#C;LM@1eJWYx-l#vVtEtUZ3
z!--*PVKh#K2nj?WBfAD6PfHd~XOf#QVEK$({jmGSV4lY5K$rsTGz)z30nS)uU_b;s
z%n)Wy<QfcC2f=7|Mka$>6Brm8m`alJK}W(dF&W&N!64AU2<0;~8Qhw~pa7O*`2P)b
zh+<I#jE1`iX4!C~(eon0e~=pp5PWi2Oz@li$kC0WhY@^BAXi>~USe*lUTOu7hCetd
zgOd*nSOb(mF^VvUAKLz42D_iv0d&hCxb>ZrT5OdBy4^kAFy6>C-oPp+GpQJQ9I#aq
z=q&Hi7CPbJ9qKATnFewv00R%`q8ux$;-X}$+{EP3$RFxaOOgAL(gi0XT~K7?sODi1
z0!ZnCi-C!O(aJa2XSApo1`$i47hvha0d%DuI9((r`v)romllAoFBwfC6bA2*)sB=d
zm?8Cu6{OV(YiTl|afhr=M;%T|2q2{k&?W;$D=RB2Xi|XnM@TVlRP8Vc0i<-n2H7A2
z5`k_3876)l^#<i306LX6H!%}>5dr1q4M`I~E30-gFh2HE@MiU1`GM8@^#+JPm>F18
zTPH9ucs!T4@_+yTf{s2&o*_XcpCLvkpCLlQy^O(3Aktr7pCLz|&u=FKqs$Hsd3_d-
zd<GT>U$)KhdO$}+hnj~+fIgR#dVxa`|Dool27N}5YU>%E*FE1b2%+jIU_8*A&SfCH
zAt;@t;NP)^0;U7a=@L@<41Bw^7?{%ePHQnRd1)~)rLh$JJ=UPW%+vsCET(e^=riy&
zYB4YuupDSk=QGe}5ZI8#z>>~V@cURp0mp&nbg58(eIAc21~!ih1~!oW4_pM~(^v|=
zA8TM}@oG-z*t4F2C6D2Mk%GHHv;TVr1E2dbKNRBq-!q8#U6>vp?&|FC7vkv`>K_^$
z91`i{8szBb?g|PW83R!0sO2+ws02s)D`+u<1UKk2=yQYYklCRo&!NS@$`G4oqR$Kt
z8L&7cWR$#|Uoxywx`7E9R)NQmV>q-JSQui`IlyKlq%$StMEcv?Fo@~fv@kJntk|j`
zZ^dAt#jqjN-=0O^riqDxZN*jt`CSg_E~vIy=rizOs9_0i&bi^$oCDfL&uVYOz^8B1
z!ot7<GSz~?)P-RKBoufo^yd4OPK*zC4UY74_V5e!@d*Y600V<Qmr6bZN2tGnJ_Db}
zfeVxL8T7RnSU~=kJ0c)2@4&#P60Z;+<L`H2vb$?Yu&cYTt6zwVXOOFNh^N0FDD1!~
zi%U(PQBNhGQBFUIVVBc-hIvlw85Vi1{g;-;<@l3<(O{0Y$G<d%e1={60-z8CnQtWk
z;%jIyC<M1e`s*`0E!PLz8(p9#4@!}YdI%Byct)*Ie}#O8J^C699P%~{;MDg}NIsrH
zRe||s2goD_CWZh|%My$s$$!L>BI?fmF0Sed>Mo8Uj_L~P0iMnw(EE=@Y?us;$3YjU
zGJrNFgPSj)v<YEAT?6NUE?EU#=EMXM0bi5>Rf9r-E@EY1VDQDE4x$@$0S5yE=!6YF
z9O~d^f-ZDrU|_Jpp$^$R(8XQ0IMgAV2f7T%o(OfIDP9L0>X7YKWB_gChKS$`7tqCC
z-b9!Oy1dN?hdN|`fG*22$Dt158b~;UE_gD-p$^$R&<*WIIMgAV2g<0XIMgAV2fD0G
z4~IHr^FSAw>Elp`Y#wOMxd9G!$mW4AH#5Yc4%s}=#b-J=)FGP(x)e<phdN~QK$oPs
z;!uZd9_V5)HzL%5E>!a%LLKO`HBTJsklkm=06J6v;u7?93K4~*7tkP>KMwPd)q&>y
zw24p$x}Z%9hdN~Ufi8J-AwnJKGPhtH>X6+B+R+k%LmjfcpiAIFai~K!4|MTa7!GyF
z=7BB}i^8D}**wr?a?v={A)5!fXf6haI%M-em(a!HP={<D=z_X99O{tG16^Jhk3$`@
zd7z8!5{OU-x|J*uhdN|?K^NjB;ZTQcFX)22WE|>{%>!MJmV!eavU#A3^-_sY2fFkw
zjR<w1OXSjtPzSoKFM|kmpo{!6iBJdHRh>nII?x4x*+i%VT@IK-ggVg0fw@Ge16?YZ
zM}#`ig@gG-r~|FOD<DE0=%T_xBGiFatP~NU4s^L(F%jxg7#J8zh)@SwUQtSfI?$zw
zWrWnh6E-0RD+4<byBuU8x0n$!j52vpL^>7}fNtlb%pd}~LH79i`he;iyeiSIwa2R#
zm!xli52${@B@Gs*iap`Zpn4H(9<2yaxCI3VIn&B~n7JT(LR=$4^b(7p7jnX6s856K
zNrK)tio<v(&<*MNc?uq>InawkaVW$i47LYUV&GBZ8?NB2@2st@5D<VhjKPw4^n;`z
z_Gp9J)F3WaOg($>dx(1W;16~x+Jo03s@aoTf!7|akw&5*I33_m)(n*T2eft-Vow3s
zKa9;<O^_}G10&ZStt<uxk5?dP6KBtK4zAT#Te$X^ZDCk_wS~iMItSNg2~gjL0d7x0
zGF~4MXAj6l*fD6GE7(5;$r<=^5Y_A<P`U-BR$+H2RFsfBNEz5aplv1~4h|d;;Otlo
zy*3$#5`w}J&i(}JIglDR1<zd2N()?N93hKR@{^$#FcVTqzC5V@DJm|)U$~KPJX|Np
zp5lxgP<s<DhK&*6N@=JuFcg=R(#0N-`}I=tX&QE*jwIL~=#}0eHa1L+^ae6lub=?3
zR2{^j0S2W5kg<9+PIMr9{POca{S1(GxG<xyZvcUk371yl#X*BdUWsLi3O<>6*{L|K
z<Dy4<6I5q`%gKzATv~QM;Pn{jj14?N<r}U53K~2r2up$elMCu95>`uz3K}O_nA5=H
zIeLlsi+(T1AZYD^J3+w=#72YCBuHE@IVZ6gPn}7P_yOCKo{2YtsOF!nM4TB6<PJ*x
z14`E*bM&e*!R<g08ylvEJ&>^qGYfCr1&8zqAFD940F4-9ivR**B#u>(Zx5ZuD*T<i
zKy!F_eeD|%4lOej$o5Zw4^5i~VE2RSZhF*(AbY@d2Z0tGybpvU)TlmIL9spfJw!eK
z;4K0XeQt{V1L<>v69*Q8YW^8)V-;kE8>o%~r)y%z5XiKL<S_(F?ZI2KGcXVuBOoLX
zN?PD>D^5)Zv1y4%c;6mJN+2BKB=+sewg=>r!P2*<M!gO8&oJuSL)yl^sYU5HyZG$G
zt!+%#HW3}l+QfnaoRJ4guhhVxHXc3t?I3%I8Q-LapL`ROGj#nyqsllth9bi)?fd$8
zk}`)42_iBAo5Z<t^6epQuAF>(=+ytDYuSXqdxPkAfI<z+{4&-1YZTjq-$U^J4aN2l
z*<YjF9=sM&%|C;!zeZ-bk=$P+(;kxhYn0kUhc?7;>qmjAEPC`i!ZY)XjT9;@%y2d#
z7(~H+Vf;lCqO7g30Il@~IiF+<u?OEO1O_VFgWp5&vWa5<;4K2F=pQ1-#whhqN-Ey@
z8<Ha(iw1Byz`N>&@^k<%Yw@mnp{6~wjUTvw@{2%gZ?S|b^@PCjL+qF$ndyz>I*L+z
z2rPZ^4Oa-y%%f}_XeMcW7czasz>w+h1lnhTH^TjsvS4#SWZMI>Ko7LS9K^tZk=FTA
zW)HpA*W_g4T{A>A{}5QmL$&zHPs+j(HDF<?*;52Q*coglHUgA+Qj4KU4x0jE#F!Zv
zIKe}G3jU=f#Av`&V{dP74;~X?WMp7Vq;T~S=#EEBD@K$EXye?7^6;o<QA2>m#m7A&
zIXg2YpeR2pJUGA^bm1%_moYFh6!t<-zF-qzVJ&=stev?~o8W2%Wc8zL%0qxT^&`V-
z@Oiaj6BravfOb%V3<a+?V_;wa?Zk#1tPI+b!Caid0a|<tYW1@)E$9dBG;RkS3eV-3
z0%~b4XJBAp3&_k1Vqjo6#=yY9o*0my$-uw>S_RMH>sgY@z`zJPyPC5k2vkEbf_74K
z`KIQTGB7ZLc8zkEIOpdvFfe8_Ffi~q=jW9$Ffg_<Ffj1u7pFQiFfcA<U|`_O%*g?<
zk1#MW@CRq)moqRhK4D;B5b(%M0h#}wfq_BLH@_^Efq@CMLtMx`wZxf$feEyGRXDZ8
zIf#LQ2~-P;RHZuSGcYi9GB7ZR=4680#<Z4!fk6za{xkyvgLsK^NG1aV(=!GJ28oiK
zutWw1X3!<sl9_qVB@7JApq=GX&LuhA3=GVm-L}#>rKy|@49uXJVwoJy;8X?%<~9Zf
z2HB9*VvzbJpp}*kMTzMQ49tfa7#QS3iV~9<7?`hu?jYcCDFT@fJ`I|Ifw6&sfdzDG
zh*DlkY6=4bizz5RGC{^Luz+@SsxU2>`+$Lg1vH)lat8wg14};x0|RImJBYoJfq?-O
zz99Bl1_szc>nxzS&;;4Xz`zQ+_#3oK9TbHiTAOLXbO8niR?w)r4g*_?3IhWxXc9vg
zlqeV&SZf&=81$g**$fN}`jGU%x`hFB<vTb%uwG|iU@(NF2i6}93=Bq)^uQ*`z`$S(
zNe^tGQ2`T3dSC<X{xpT82R2YWZU#vYY`qK&4CavZz_to>LIWf{u$=&%!T?DRY@m3t
zf}{s_HU<U;Ye;%v2c=sZNP1wmXJBBkg`@{|&`wS}Nc^&c{9+GD59}bnI6%?^`yS9~
z29WS)zs<nF-~?6wlYxQ38Im42#26SDTp;Oz1GGcK6_Oq}K=I-RNe>)_3=9nJko3SY
zk%5811Cky%K=I-UNe>(+K|9i2!0CbGIRgWOHzYl9f)11Rfusjc(5VTa9m^9K7&xsN
z7#KjilGzv-I6=EeK|7Bb85lV085kHq`I3u)fpY-^0|RIWF{pjCmw|x+lo$CJ7&z}U
zFff323=1+aaQ<dsU;w#Qgn@wzl*T|if5jOXxIiZYfOhvXF)(m}%m(e?m0@7u0_}~6
z@J_8PW?<j~#Y-du1B(Cy0~aV>qCoo@7#O%f`8^u6n2dpe>oEfZLyR|rQz8QcH^?us
zIRy;93=G^Lzr-;xfocWTM7?}++ijo}2&z?lo%}$1{$R^iLBdqUqisUUgLAY^NO>3z
zWfPe6K*yF0Wgk%J_R&+X-~l*#>J>aFC}c1(Fi3#fL^w`CfVJO2SBZeyU6wf1!Ck?`
zz#v7;sZ~rwo?6Akz#v1+sZ~r23`Ct;#l*ls)TvcW4B#{U2%cKS#K1t*sZ~r244^g(
z!BeZ4Abll*r&cjBFo60b1W&DEVqgHZ=?R`%#RO^Z6Fjww3DOrJcxn|B0|TfZK=9Nm
zCI$x34ts*9RxvR!fQo;Dr&cjBFo61!1W&DEVqgHZQ3;+}#l*ls)TvcW3=Bk_TE)b`
z0P3?4Jhh66fq|$~tC$!VK>Y@Sr&cjBFc5WW6%zvksG&vh)G8(h22g96;Hgzi3=Bk_
zTE)b`0O~6eJhh66fdSM~CwOWV69WUNA5HMoDkcU7&~9sjr&cjBFo62~1W&DEVqgG`
zKM*{%iiv>%G@C;3)G8(h2GAZPf~Qt7F))C}TnL_8#l!&WKQRzIwTcPSKO}f+6%zvk
zsDDTB)G8)OzmnjoRZNgRC&5#zm>_*nf~Qt7LHefzPpx8NU;y=937%TT#J~XR*AhIn
ziiv>%)aNC5Y84X$18CfW;Hgzi3=Bk_TE)b`K-8&KObiS}om$1jzyKQSAb4sO69WTL
zr&cjBFo4Dz2%cKS#K1t*sZ~r244`o(f~Qt7F))DU6bYVM#l*mn#K6En@YE_M1_sbl
z4}zywF)=WJ#xn_?TE)b`09vg~@YE_M1_scWDfLdR8oezH-gX^jV1@vw12B497-qPP
zbP=R<F?w6rNKXt%{zpm|qql`2h0921!qUa)ZDAulC7}8rDP4@-7KR!$BbtYlE=F$)
z8wKzXKuQ;EpxJ-8#3*Al1V%$(WQPD30|VsbhJXNP+&j-kb{LKNeprWqQ+|GNiC#!X
zQEFleo`V;MZx}E#FoGs9hpz`meMV9UjNZzDGq{j;onbl00;e_<2@+4bB;TIlc+$w|
ztsE$6iRve(;7D!6+XI^7MR6hu2fmx1Vta_(%}=>KcrBuue+JvhDP)EleD`|>WS9Nu
ztsIc#PbmMuciDq>6hX9LB?+CFNk|@KDEQO>0u9~KTRA`>g}|T%GlS{Wy3t!X5OD)y
zfi_@)XgvbE`A2W%0EH3)gVOcrtsIE(Kw>e1%gNDOIgo;cI3_*HN$_4?(1zI2TRDh}
z6sRiD0(1~lZ}e6UP%uyxgUZrDdV?t0r*4xtRzbc!bQ-G|y_JLXBo9j0;JOfh*B)_#
z9*$H%s1F2k8N?nUPadS$9{e7H_w6aR2k#I96~hhE=LUr%HcU1D47RZfGUEq6Rzd6u
zdSu!I@7oi5vnQqY&}|H1^i~dR`3#pBs2nBcM0%vYJ&u%s%Lat_=&c-xuppH+oNnBN
ztnC0F)rTt>MsMZ76*73lL3tV6R-r>#J9;Yzo`}FB1v)H!^i~ec079C>h6E9&5`rS5
zw{j2+A`AtfGGp{sjsVbEhA3e}e7}&${u(G%W0}7s-X0?RYn0oA*CKd-jZ%9CTYrsA
z|B&2YBhwy|`)iciLx(oR=&c+mMGjFM(46AvtsK~c3SKr*aF#r{{hW-q2t<sHQEm@j
zi>T(G(OWsNCm0-}@G>2`UI>RWiqiqyp8U~UIdFwBHgR}eIC?7ww%{QsHhL=u!63q_
zfY3S~s@;|`oNnb{V`O9iZT7?(q9ad`<4oEFh_6`%xVD~xEqwqBah$#d>W+ii44_l-
zAuKc!RBJFmPVGaJA&m<)hcr!?szHS@rYIf<QpsMdc47#Uk@CP=KxdR=7zPypD`4Pg
zU|_)X3eM1g>cv8#UU5Od00#z)gdqquQv*uVn1c8oVF~Ou2!sfJ7IM1A8Olh8Dj>13
znhcYN(O4Cs3L*j-*)^zYXvM?nOw7bYoD*P02)X*f=i?$-h0}pZYOpX_Kt~IM#c{?e
z0|O%9!74!n=#~aZ1p&H810*tvM?(M{0*s6d47rJ!d0@^+C72l)7<Mu+KK4`aX7yhA
zfz|sp^u8o!2G-Qp2@DJ#&*iQB-~Yd$qYsj2NKnaVh|$Ssh){4ZV=xnl^w-yC$kFHX
z+sVKvvqM8(pT#4efd#^sZF9UH&=Jw0=HU^b&*h|E;84VWsJW>@pAn?mdWPq9&o>N0
zs5%N54>YH983=C(N@pqfcdVg+=|FS3gp@u5-!3f%rgXm3S`18HS`18SECqj$H7GDM
zH83zRF{E<{=riy&YB4YuupDSk=QGe}5ZI8#z>>~V@cURp0mp&nbg58(eIAc21~!ih
z1~!oW4_pM~(^v|=A8TM}@oG-z*t4F2C6D2Mk%GHHv;TVr1E2dbKNRBq-!q8#U6>vp
z?&|FC7vkv`>K_^$91`i{8szBb?g|PW83R!0sO2+ws02s)D`+u<1UKk2=yQYYklCRo
z&!NS@$`G4oqR$Kt8L&7cWR$#|Uoxywx`7E9R)I^+7!EB47KWH~4zL*s=}ZYZk^c5J
z3}X5=Eldm?E4C`gTQOK@F>DC+w`b9}X<}kvTd~zZewRbK3#x4v`V2f6YFL7sb8dJw
z=YZ~GVYRnm;M2EhVPW6_nQFmc>cX%A5(+#Pdh`8CC&q`n21oiid-#R=_ymIjfPq1u
zOC_IyBh=qOpMlTgz=cWr4EkCOEFgc&9TAY1cVOUCiC2h^@%Oth+1)iH*wx+F)i1=w
zGsx9B#M9po6n5a0#igdtsHc+8D5oF9u*+#Z!#t<;42!(h{!2^aa{S4_XfQ|H<6oLW
zKEp130Z<5n%(oH%@ijCU6oOkK{q>ohmg|G<jV@4=2c<|xJ%osUJfl{qzd}C49(@f4
z4tW~}aO!&~Bp=V9s=)lR17s5DgqYF0{RUSNIJ!H3aK#7RT{C*OAKinTG7CrV_8Yz1
z50ZjdL3etL-tEUQdbb|~sChnmw;$-5($V{#A%z14<Y=3ag1{RFT1Wide(Vg)+$E4h
z+w^iWlTwO7Bx=Nh?kNRfR8b;%qj$=KueBmFv__SUh5+dyz=)JP*%_Dxq4`-iB{iuu
z9h9FTB+OutY7mC;Nuo#d^Jso1DZz{?COHI<^D_gZ1_Of#LvC>i+WKZu4F(1_ka!NN
z`O+Go4pMG$3EC`_rYLA89%2sj3xpm+QG_|j;<8BQAd6esFfcHP6cnYVF?8LS#lXP8
z12M}Aw9uCeBEAnaCCdvH2i*$C0}*dH&cMLH2Neh1CdLO5Us1upz`zd`FJWL{WCM$L
zhl2bJohG(E#=yXM3oPE%caDL9K^UUmb^!weYac{>!a|VSAmYw?3=FIs5b@8Tn;S(T
z;vQxU42%L0@pF$D7#PGL;+}2{4E%Q>;=j8Y7#PGM;*p@+Q;i_v+dwzhfo`p3U|>kS
zz`(%S01>a=%)r0^x}}zZfgwMDfq@wkKHYX8y`WoZ85kJmMlmpOG31sMfZ_{jO@g8Z
z0|O&S9CVf#lDHCRd4xc2NkJy;lop74G(h(J$t}qNozaA(J_&RStwL@|F`D^G77Pq5
zCb=c)ISdTQ@u<iRii_O*5|H^2qrs%PC<6o2fdHT45{7P<FAR`dTp1V`VnP`hm~?Ur
ziZfBokq5a`Bexi24zl_3pj!i>;$VZJM2s&30|Q5HVh+fiP%#jdWXr(7up~DT96lfc
zC{CTjz`&pc4rfVoP&(0sNTh&n*@T3%q<uXD<knYEyzFCOU=RYUmjGQ12)^Z&fq|jr
z3<Cp$6hu6Yoq>Tt2Vzbw=$1T4`jq$&O0&8U@s?){3=EUN>LtTLH{R+&#9Kjb$O4N?
zECE>nx*e8*fgu?bFEU_pZgJ2}gP_}B85kJk8$tdBiz`0`-GmCdZI6M0q4g011K%Eq
z_?5W~klXb@7XYR(Ft9+<r%GEL0|P@k#NM(J1_m~Wf0bu|(o_aSe0dZDgZ>VPIrl+f
z3ysg(0tN;)1+ch^!94~BhAfEsDf1W@n4#iID;XFVvLWKr_c1UqL-L*S)N2e34AA(I
z?_^+LU;&$>{Pj5l14AxEy?ie`Je9v}WME)`mN)Xt85kJsAnIp>@-HZzg2Le`D7}Hj
zReX*yFfc$@l3y2MU|?Pb5%=<7U|=YOn*W)Bf#C*NTzSS?P{2UMZ|z`UU=st2tHgrh
z3Y2dc7#I{zgYrH^++#8W149W!y~2G^9tVpn_wQt2U?_!(e`R1`fRtCtM?rB~1{MDg
zD$~H~RqR3bmP5qVY8V(8PC>+LrZ6xtfb=jhFsOrWaZLh?EAOddU|^_(sDE&dfq~@>
zMEvzp1_lO@90LPGWC#NTqXb0!aVrA@Lp4}EV`Lfw1M>y2xQb;n0|NudK9Kn<KnFB|
z#gz|&Ze*<mt7n*Xgn@wxl5SNLL17C@D<Ji^K!E`*2SDX8L^;C?0i^N=NjxeCsr*3_
zR|CaAto%U|PXMJ~Sown_E)OdIA?2-#{woH^?Xe6D44(wx>0AYzMnJd4f~-7)Nar0#
zKsR@T9m>dZ2cFJVv|lnnZi8iDVC4D$Pv<HOpz;}X`zr$jqtyy{I#>Q|%>cRWm4SiL
z;RGU`3tVM@-0sT2!07w}p3YUmKxJkS*j@%jQ2vFc^D`$HAh*1N!t)m*o$pd+fZXcJ
zz`$S$G82-{ReC|?Jm?lz1_lNzP`w1H*Hl>57#P5}wlXj<y1hfB^9WG=3%aG1fq@|!
z6wZ)zu3`aNS_it7m4SiLYYHNrtIP)_9EdxuK(~HF$^n%oQ27t4Ul|w}tU>7unlEfY
z^&_aRVqjoU1o;t?&Q(}Wf(mkoIo6<6ozV1?2vQ3w%NQ6K;y~pUB%Le2UJnw0sE-Gw
zJxDrNsRz~hpj%QI7#IUq!PB`)5GZb;D?(Eu;pto@3Uu={=oVB42FB27@N}+xIG6!)
j>nQ^RLp&(2=|R%@MNk_9x=r!vE<`$K-Om8I)sz7MA;J(n

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 e391a34f63244dd3207a6cbc0a6498f03ae44b82..f27f0b97b8e1381d3f88de11936d3989c59287df 100644
GIT binary patch
delta 14
WcmaE`i21h6hJIc~g~=0mPXhoiw*}<@

literal 53600
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

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