[Boost-commit] svn:boost r57521 - in sandbox/fiber: boost/fiber libs/fiber/build libs/fiber/src libs/fiber/test

Subject: [Boost-commit] svn:boost r57521 - in sandbox/fiber: boost/fiber libs/fiber/build libs/fiber/src libs/fiber/test
From: oliver.kowalke_at_[hidden]
Date: 2009-11-09 13:27:36

Author: olli
Date: 2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
New Revision: 57521
URL: http://svn.boost.org/trac/boost/changeset/57521

Log:
- tests for sync. primitives added

Added:
   sandbox/fiber/libs/fiber/test/condition_test_common.hpp   (contents, props changed)
   sandbox/fiber/libs/fiber/test/test_auto_reset_event.cpp   (contents, props changed)
   sandbox/fiber/libs/fiber/test/test_condition.cpp   (contents, props changed)
   sandbox/fiber/libs/fiber/test/test_count_down_event.cpp   (contents, props changed)
   sandbox/fiber/libs/fiber/test/test_generic_locks.cpp   (contents, props changed)
   sandbox/fiber/libs/fiber/test/test_manual_reset_event.cpp   (contents, props changed)
   sandbox/fiber/libs/fiber/test/test_unique_lock.cpp   (contents, props changed)
Text files modified: 
   sandbox/fiber/boost/fiber/exceptions.hpp     |     5 ++                                      
   sandbox/fiber/boost/fiber/scheduler.hpp      |     4 ++                                      
   sandbox/fiber/libs/fiber/build/Jamfile.v2    |     2 +                                       
   sandbox/fiber/libs/fiber/src/fiber.cpp       |    12 +++++-                                  
   sandbox/fiber/libs/fiber/src/scheduler.cpp   |    11 ++++++                                  
   sandbox/fiber/libs/fiber/test/Jamfile.v2     |     5 ++                                      
   sandbox/fiber/libs/fiber/test/test_mutex.cpp |    68 +++++++++++++++++++++++++++++++++++++-- 
   7 files changed, 100 insertions(+), 7 deletions(-)

Modified: sandbox/fiber/boost/fiber/exceptions.hpp
==============================================================================
--- sandbox/fiber/boost/fiber/exceptions.hpp	(original)
+++ sandbox/fiber/boost/fiber/exceptions.hpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -10,6 +10,8 @@
 #include <stdexcept>
 #include <string>
 
+#include <boost/fiber/detail/config.hpp>
+
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost {
@@ -23,6 +25,9 @@
         {}
 };
 
+class fiber_interrupted
+{};
+
 class invalid_stacksize : public std::runtime_error
 {
 public:

Modified: sandbox/fiber/boost/fiber/scheduler.hpp
==============================================================================
--- sandbox/fiber/boost/fiber/scheduler.hpp	(original)
+++ sandbox/fiber/boost/fiber/scheduler.hpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -56,9 +56,13 @@
 
         static void exit();
 
+	static void failed();
+
         policy * access_();
 
 public:
+	~scheduler();
+
         template< typename Fn >
         void make_fiber( Fn fn)
         {

Modified: sandbox/fiber/libs/fiber/build/Jamfile.v2
==============================================================================
--- sandbox/fiber/libs/fiber/build/Jamfile.v2	(original)
+++ sandbox/fiber/libs/fiber/build/Jamfile.v2	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -36,6 +36,7 @@
 alias fiber_sources
     : ## win32 sources ##
         attributes.cpp
+	auto_reset_event.cpp
         condition.cpp
         count_down_event.cpp
         fiber.cpp
@@ -52,6 +53,7 @@
 alias fiber_sources
     : ## posix sources ##
         attributes.cpp
+	auto_reset_event.cpp
         condition.cpp
         count_down_event.cpp
         fiber.cpp

Modified: sandbox/fiber/libs/fiber/src/fiber.cpp
==============================================================================
--- sandbox/fiber/libs/fiber/src/fiber.cpp	(original)
+++ sandbox/fiber/libs/fiber/src/fiber.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -8,6 +8,7 @@
 
 #include <boost/assert.hpp>
 
+#include <boost/fiber/exceptions.hpp>
 #include <boost/fiber/scheduler.hpp>
 
 #include <boost/config/abi_prefix.hpp>
@@ -43,8 +44,15 @@
 {
         BOOST_ASSERT( self);
         BOOST_ASSERT( self->info_);
-	self->info_->run();
- 	scheduler::exit();
+	try
+	{
+		self->info_->run();
+ 		scheduler::exit();
+	}
+	catch ( fiber_interrupted const&)
+	{ scheduler::failed(); }
+	catch (...)
+	{ scheduler::failed(); }
 }
 
 }}

Modified: sandbox/fiber/libs/fiber/src/scheduler.cpp
==============================================================================
--- sandbox/fiber/libs/fiber/src/scheduler.cpp	(original)
+++ sandbox/fiber/libs/fiber/src/scheduler.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -44,6 +44,14 @@
         impl->exit_active_fiber();
 }
 
+void
+scheduler::failed()
+{
+	policy * impl( impl_.get() );
+	if (  ! impl) throw fiber_error("not a fiber");
+	impl->exit_active_fiber();
+}
+
 policy *
 scheduler::access_()
 {
@@ -55,6 +63,9 @@
         return impl_.get();
 }
 
+scheduler::~scheduler()
+{ impl_.reset(); }
+
 bool
 scheduler::run()
 { return access_()->run(); }

Modified: sandbox/fiber/libs/fiber/test/Jamfile.v2
==============================================================================
--- sandbox/fiber/libs/fiber/test/Jamfile.v2	(original)
+++ sandbox/fiber/libs/fiber/test/Jamfile.v2	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -29,4 +29,9 @@
     [ fiber-test test_rrp ]
     [ fiber-test test_utility ]
     [ fiber-test test_mutex ]
+    [ fiber-test test_auto_reset_event ]
+    [ fiber-test test_manual_reset_event ]
+    [ fiber-test test_count_down_event ]
+    [ fiber-test test_unique_lock ]
+    [ fiber-test test_condition ]
     ;

Added: sandbox/fiber/libs/fiber/test/condition_test_common.hpp
==============================================================================
--- (empty file)
+++ sandbox/fiber/libs/fiber/test/condition_test_common.hpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -0,0 +1,97 @@
+#ifndef TASK_CONDITION_TEST_COMMON_HPP
+#define TASK_CONDITION_TEST_COMMON_HPP
+// Copyright (C) 2007 Anthony Williams
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/utility.hpp>
+#include <boost/thread/thread_time.hpp>
+
+#include <boost/fiber.hpp>
+
+unsigned const timeout_seconds=5;
+
+struct wait_for_flag : private boost::noncopyable
+{
+    boost::fiber::mutex mutex;
+    boost::fiber::condition cond_var;
+    bool flag;
+    unsigned woken;
+        
+    wait_for_flag():
+        flag(false),woken(0)
+    {}
+
+    struct check_flag
+    {
+        bool const& flag;
+            
+        check_flag(bool const& flag_):
+            flag(flag_)
+        {}
+            
+        bool operator()() const
+        {
+            return flag;
+        }
+    private:
+        void operator=(check_flag&);
+    };
+
+        
+    void wait_without_predicate()
+    {
+        boost::fiber::mutex::scoped_lock lock(mutex);
+        while(!flag)
+        {
+            cond_var.wait(lock);
+        }
+        ++woken;
+    }
+
+    void wait_with_predicate()
+    {
+        boost::fiber::mutex::scoped_lock lock(mutex);
+        cond_var.wait(lock,check_flag(flag));
+        if(flag)
+        {
+            ++woken;
+        }
+    }
+
+    void timed_wait_without_predicate()
+    {
+        boost::system_time const timeout=boost::get_system_time()+boost::posix_time::seconds(timeout_seconds);
+            
+        boost::fiber::mutex::scoped_lock lock(mutex);
+        while(!flag)
+        {
+            if(!cond_var.timed_wait(lock,timeout))
+            {
+                return;
+            }
+        }
+        ++woken;
+    }
+
+    void timed_wait_with_predicate()
+    {
+        boost::system_time const timeout=boost::get_system_time()+boost::posix_time::seconds(timeout_seconds);
+        boost::fiber::mutex::scoped_lock lock(mutex);
+        if(cond_var.timed_wait(lock,timeout,check_flag(flag)) && flag)
+        {
+            ++woken;
+        }
+    }
+    void relative_timed_wait_with_predicate()
+    {
+        boost::fiber::mutex::scoped_lock lock(mutex);
+        if(cond_var.timed_wait(lock,boost::posix_time::seconds(timeout_seconds),check_flag(flag)) && flag)
+        {
+            ++woken;
+        }
+    }
+};
+
+#endif

Added: sandbox/fiber/libs/fiber/test/test_auto_reset_event.cpp
==============================================================================
--- (empty file)
+++ sandbox/fiber/libs/fiber/test/test_auto_reset_event.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -0,0 +1,124 @@
+
+//          Copyright Oliver Kowalke 2009.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/fiber.hpp>
+
+int value = 0;
+
+void wait_fn( boost::fiber::auto_reset_event & ev)
+{
+	ev.wait();
+	++value;
+}
+
+// check wait
+void test_case_1()
+{
+	value = 0;
+	boost::fiber::auto_reset_event ev;
+	boost::fiber::scheduler sched;
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	ev.set();
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	ev.set();
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 0), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+}
+
+void test_case_2()
+{
+	value = 0;
+	boost::fiber::auto_reset_event ev( true);
+	boost::fiber::scheduler sched;
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	ev.set();
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 0), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+}
+
+void test_case_3()
+{
+	boost::fiber::auto_reset_event ev;
+
+	BOOST_CHECK_EQUAL( false, ev.try_wait() );
+
+	ev.set();
+
+	BOOST_CHECK_EQUAL( true, ev.try_wait() );
+	BOOST_CHECK_EQUAL( false, ev.try_wait() );
+}
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+	boost::unit_test::test_suite * test =
+		BOOST_TEST_SUITE("Boost.Fiber: auto-reset-event test suite");
+
+	test->add( BOOST_TEST_CASE( & test_case_1) );
+	test->add( BOOST_TEST_CASE( & test_case_2) );
+	test->add( BOOST_TEST_CASE( & test_case_3) );
+
+	return test;
+}

Added: sandbox/fiber/libs/fiber/test/test_condition.cpp
==============================================================================
--- (empty file)
+++ sandbox/fiber/libs/fiber/test/test_condition.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -0,0 +1,229 @@
+
+//          Copyright Oliver Kowalke 2009.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/fiber.hpp>
+
+int value = 0;
+
+void notify_one_fn( boost::fiber::condition & cond)
+{
+	cond.notify_one();
+}
+
+void notify_all_fn( boost::fiber::condition & cond)
+{
+	cond.notify_all();
+}
+
+void wait_fn(
+	boost::fiber::mutex & mtx,
+	boost::fiber::condition & cond)
+{
+	boost::fiber::mutex::scoped_lock lk( mtx);
+	cond.wait( lk);
+	++value;
+}
+
+void test_case_1()
+{
+	value = 0;
+	boost::fiber::mutex mtx;
+	boost::fiber::condition cond;
+	boost::fiber::scheduler sched;
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( mtx),
+		boost::ref( cond) );
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	sched.make_fiber(
+		notify_one_fn,
+		boost::ref( cond) );
+
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 0), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+}
+
+void test_case_2()
+{
+	value = 0;
+	boost::fiber::mutex mtx;
+	boost::fiber::condition cond;
+	boost::fiber::scheduler sched;
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( mtx),
+		boost::ref( cond) );
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( mtx),
+		boost::ref( cond) );
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	sched.make_fiber(
+		notify_one_fn,
+		boost::ref( cond) );
+
+	BOOST_CHECK_EQUAL( std::size_t( 3), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 3), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+}
+
+void test_case_3()
+{
+	value = 0;
+	boost::fiber::mutex mtx;
+	boost::fiber::condition cond;
+	boost::fiber::scheduler sched;
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( mtx),
+		boost::ref( cond) );
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( mtx),
+		boost::ref( cond) );
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	sched.make_fiber(
+		notify_all_fn,
+		boost::ref( cond) );
+
+	BOOST_CHECK_EQUAL( std::size_t( 3), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 3), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( mtx),
+		boost::ref( cond) );
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+
+	sched.make_fiber(
+		notify_all_fn,
+		boost::ref( cond) );
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 0), sched.size() );
+	BOOST_CHECK_EQUAL( 3, value);
+}
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+	boost::unit_test::test_suite * test =
+		BOOST_TEST_SUITE("Boost.Fiber: condition test suite");
+
+	test->add( BOOST_TEST_CASE( & test_case_1) );
+	test->add( BOOST_TEST_CASE( & test_case_2) );
+	test->add( BOOST_TEST_CASE( & test_case_3) );
+
+	return test;
+}

Added: sandbox/fiber/libs/fiber/test/test_count_down_event.cpp
==============================================================================
--- (empty file)
+++ sandbox/fiber/libs/fiber/test/test_count_down_event.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -0,0 +1,91 @@
+
+//          Copyright Oliver Kowalke 2009.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/function.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/fiber.hpp>
+
+int value = 0;
+
+void wait_fn( boost::fiber::count_down_event & ev)
+{
+	ev.wait();
+	++value;
+}
+
+void test_case_1()
+{
+	boost::uint32_t n = 3;
+	boost::fiber::count_down_event ev( n);
+
+	BOOST_CHECK_EQUAL( ev.initial(), n);
+	BOOST_CHECK_EQUAL( ev.current(), n);
+
+	ev.set();
+	BOOST_CHECK_EQUAL( ev.initial(), n);
+	BOOST_CHECK_EQUAL( ev.current(), static_cast< boost::uint32_t >( 2) );
+
+	ev.set();
+	BOOST_CHECK_EQUAL( ev.initial(), n);
+	BOOST_CHECK_EQUAL( ev.current(), static_cast< boost::uint32_t >( 1) );
+
+	ev.set();
+	BOOST_CHECK_EQUAL( ev.initial(), n);
+	BOOST_CHECK_EQUAL( ev.current(), static_cast< boost::uint32_t >( 0) );
+
+	ev.set();
+	BOOST_CHECK_EQUAL( ev.initial(), n);
+	BOOST_CHECK_EQUAL( ev.current(), static_cast< boost::uint32_t >( 0) );
+}
+
+void test_case_2()
+{
+	value = 0;
+	boost::uint32_t n = 3;
+	boost::fiber::count_down_event ev( n);
+	boost::fiber::scheduler sched;
+
+	BOOST_CHECK_EQUAL( ev.initial(), n);
+	BOOST_CHECK_EQUAL( ev.current(), n);
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	for ( boost::uint32_t i = 0; i < n - 1; ++i)
+	{
+		ev.set();
+		BOOST_CHECK( sched.run() );
+		BOOST_CHECK( value != 1);
+	}
+	ev.set();
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( ev.initial(), n);
+	BOOST_CHECK_EQUAL( ev.current(), static_cast< boost::uint32_t >( 0) );
+	BOOST_CHECK_EQUAL( 1, value);
+}
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+	boost::unit_test::test_suite * test =
+		BOOST_TEST_SUITE("Boost.Task: spin-count-down-event test suite");
+
+	test->add( BOOST_TEST_CASE( & test_case_1) );
+	test->add( BOOST_TEST_CASE( & test_case_2) );
+
+	return test;
+}

Added: sandbox/fiber/libs/fiber/test/test_generic_locks.cpp
==============================================================================
--- (empty file)
+++ sandbox/fiber/libs/fiber/test/test_generic_locks.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -0,0 +1,524 @@
+// (C) Copyright 2008 Anthony Williams
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread.hpp>
+#include <boost/fiber.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+namespace tsk = boost::task;
+
+void test_lock_two_uncontended()
+{
+    boost::fiber::mutex m1,m2;
+
+    boost::fiber::mutex::scoped_lock l1(m1,boost::defer_lock),
+        l2(m2,boost::defer_lock);
+
+    BOOST_CHECK(!l1.owns_lock());
+    BOOST_CHECK(!l2.owns_lock());
+    
+    boost::lock(l1,l2);
+    
+    BOOST_CHECK(l1.owns_lock());
+    BOOST_CHECK(l2.owns_lock());
+}
+
+struct wait_data
+{
+    boost::fiber::mutex m;
+    bool flag;
+    boost::fiber::condition cond;
+    
+    wait_data():
+        flag(false)
+    {}
+    
+    void wait()
+    {
+        boost::fiber::mutex::scoped_lock l(m);
+        while(!flag)
+        {
+            cond.wait(l);
+        }
+    }
+
+    template<typename Duration>
+    bool timed_wait(Duration d)
+    {
+        boost::system_time const target=boost::get_system_time()+d;
+        
+        boost::fiber::mutex::scoped_lock l(m);
+        while(!flag)
+        {
+            if(!cond.timed_wait(l,target))
+            {
+                return flag;
+            }
+        }
+        return true;
+    }
+    
+    void signal()
+    {
+        boost::fiber::mutex::scoped_lock l(m);
+        flag=true;
+        cond.notify_all();
+    }
+};
+       
+
+void lock_mutexes_slowly(boost::fiber::mutex* m1,boost::fiber::mutex* m2,wait_data* locked,wait_data* quit)
+{
+    boost::lock_guard<boost::fiber::mutex> l1(*m1);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(500));
+    boost::lock_guard<boost::fiber::mutex> l2(*m2);
+    locked->signal();
+    quit->wait();
+}
+
+void lock_pair(boost::fiber::mutex* m1,boost::fiber::mutex* m2)
+{
+    boost::lock(*m1,*m2);
+    boost::fiber::mutex::scoped_lock l1(*m1,boost::adopt_lock),
+        l2(*m2,boost::adopt_lock);
+}
+
+void test_lock_two_other_thread_locks_in_order()
+{
+    boost::fiber::mutex m1,m2;
+    wait_data locked;
+    wait_data release;
+    
+    boost::thread t(lock_mutexes_slowly,&m1,&m2,&locked,&release);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(10));
+
+    boost::thread t2(lock_pair,&m1,&m2);
+    BOOST_CHECK(locked.timed_wait(boost::posix_time::seconds(1)));
+
+    release.signal();
+    
+    BOOST_CHECK(t2.timed_join(boost::posix_time::seconds(1)));
+
+    t.join();
+}
+
+void test_lock_two_other_thread_locks_in_opposite_order()
+{
+    boost::fiber::mutex m1,m2;
+    wait_data locked;
+    wait_data release;
+    
+    boost::thread t(lock_mutexes_slowly,&m1,&m2,&locked,&release);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(10));
+
+    boost::thread t2(lock_pair,&m2,&m1);
+    BOOST_CHECK(locked.timed_wait(boost::posix_time::seconds(1)));
+
+    release.signal();
+    
+    BOOST_CHECK(t2.timed_join(boost::posix_time::seconds(1)));
+
+    t.join();
+}
+
+void test_lock_five_uncontended()
+{
+    boost::fiber::mutex m1,m2,m3,m4,m5;
+
+    boost::fiber::mutex::scoped_lock l1(m1,boost::defer_lock),
+        l2(m2,boost::defer_lock),
+        l3(m3,boost::defer_lock),
+        l4(m4,boost::defer_lock),
+        l5(m5,boost::defer_lock);
+
+    BOOST_CHECK(!l1.owns_lock());
+    BOOST_CHECK(!l2.owns_lock());
+    BOOST_CHECK(!l3.owns_lock());
+    BOOST_CHECK(!l4.owns_lock());
+    BOOST_CHECK(!l5.owns_lock());
+    
+    boost::lock(l1,l2,l3,l4,l5);
+    
+    BOOST_CHECK(l1.owns_lock());
+    BOOST_CHECK(l2.owns_lock());
+    BOOST_CHECK(l3.owns_lock());
+    BOOST_CHECK(l4.owns_lock());
+    BOOST_CHECK(l5.owns_lock());
+}
+
+void lock_five_mutexes_slowly(boost::fiber::mutex* m1,boost::fiber::mutex* m2,boost::fiber::mutex* m3,boost::fiber::mutex* m4,boost::fiber::mutex* m5,
+                              wait_data* locked,wait_data* quit)
+{
+    boost::lock_guard<boost::fiber::mutex> l1(*m1);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(500));
+    boost::lock_guard<boost::fiber::mutex> l2(*m2);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(500));
+    boost::lock_guard<boost::fiber::mutex> l3(*m3);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(500));
+    boost::lock_guard<boost::fiber::mutex> l4(*m4);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(500));
+    boost::lock_guard<boost::fiber::mutex> l5(*m5);
+    locked->signal();
+    quit->wait();
+}
+
+void lock_five(boost::fiber::mutex* m1,boost::fiber::mutex* m2,boost::fiber::mutex* m3,boost::fiber::mutex* m4,boost::fiber::mutex* m5)
+{
+    boost::lock(*m1,*m2,*m3,*m4,*m5);
+    m1->unlock();
+    m2->unlock();
+    m3->unlock();
+    m4->unlock();
+    m5->unlock();
+}
+
+void test_lock_five_other_thread_locks_in_order()
+{
+    boost::fiber::mutex m1,m2,m3,m4,m5;
+    wait_data locked;
+    wait_data release;
+    
+    boost::thread t(lock_five_mutexes_slowly,&m1,&m2,&m3,&m4,&m5,&locked,&release);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(10));
+
+    boost::thread t2(lock_five,&m1,&m2,&m3,&m4,&m5);
+    BOOST_CHECK(locked.timed_wait(boost::posix_time::seconds(3)));
+
+    release.signal();
+    
+    BOOST_CHECK(t2.timed_join(boost::posix_time::seconds(3)));
+
+    t.join();
+}
+
+void test_lock_five_other_thread_locks_in_different_order()
+{
+    boost::fiber::mutex m1,m2,m3,m4,m5;
+    wait_data locked;
+    wait_data release;
+    
+    boost::thread t(lock_five_mutexes_slowly,&m1,&m2,&m3,&m4,&m5,&locked,&release);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(10));
+
+    boost::thread t2(lock_five,&m5,&m1,&m4,&m2,&m3);
+    BOOST_CHECK(locked.timed_wait(boost::posix_time::seconds(3)));
+
+    release.signal();
+    
+    BOOST_CHECK(t2.timed_join(boost::posix_time::seconds(3)));
+
+    t.join();
+}
+
+void lock_n(boost::fiber::mutex* mutexes,unsigned count)
+{
+    boost::lock(mutexes,mutexes+count);
+    for(unsigned i=0;i<count;++i)
+    {
+        mutexes[i].unlock();
+    }
+}
+
+
+void test_lock_ten_other_thread_locks_in_different_order()
+{
+    unsigned const num_mutexes=10;
+    
+    boost::fiber::mutex mutexes[num_mutexes];
+    wait_data locked;
+    wait_data release;
+    
+    boost::thread t(lock_five_mutexes_slowly,&mutexes[6],&mutexes[3],&mutexes[8],&mutexes[0],&mutexes[2],&locked,&release);
+    boost::this_fiber::sleep(boost::posix_time::milliseconds(10));
+
+    boost::thread t2(lock_n,mutexes,num_mutexes);
+    BOOST_CHECK(locked.timed_wait(boost::posix_time::seconds(3)));
+
+    release.signal();
+
+    BOOST_CHECK(t2.timed_join(boost::posix_time::seconds(3)));
+
+    t.join();
+}
+
+struct dummy_mutex
+{
+    bool is_locked;
+    
+    dummy_mutex():
+        is_locked(false)
+    {}
+    
+    void lock()
+    {
+        is_locked=true;
+    }
+    
+    bool try_lock()
+    {
+        if(is_locked)
+        {
+            return false;
+        }
+        is_locked=true;
+        return true;
+    }
+    
+    void unlock()
+    {
+        is_locked=false;
+    }
+};
+
+namespace boost
+{
+    template<>
+    struct is_mutex_type<dummy_mutex>
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+}
+
+
+
+void test_lock_five_in_range()
+{
+    unsigned const num_mutexes=5;
+    dummy_mutex mutexes[num_mutexes];
+
+    boost::lock(mutexes,mutexes+num_mutexes);
+    
+    for(unsigned i=0;i<num_mutexes;++i)
+    {
+        BOOST_CHECK(mutexes[i].is_locked);
+    }
+}
+
+void test_lock_ten_in_range()
+{
+    unsigned const num_mutexes=10;
+    dummy_mutex mutexes[num_mutexes];
+
+    boost::lock(mutexes,mutexes+num_mutexes);
+    
+    for(unsigned i=0;i<num_mutexes;++i)
+    {
+        BOOST_CHECK(mutexes[i].is_locked);
+    }
+}
+
+void test_try_lock_two_uncontended()
+{
+    dummy_mutex m1,m2;
+
+    int const res=boost::try_lock(m1,m2);
+    
+    BOOST_CHECK(res==-1);
+    BOOST_CHECK(m1.is_locked);
+    BOOST_CHECK(m2.is_locked);
+}
+void test_try_lock_two_first_locked()
+{
+    dummy_mutex m1,m2;
+    m1.lock();
+
+    boost::unique_lock<dummy_mutex> l1(m1,boost::defer_lock),
+        l2(m2,boost::defer_lock);
+
+    int const res=boost::try_lock(l1,l2);
+    
+    BOOST_CHECK(res==0);
+    BOOST_CHECK(m1.is_locked);
+    BOOST_CHECK(!m2.is_locked);
+    BOOST_CHECK(!l1.owns_lock());
+    BOOST_CHECK(!l2.owns_lock());
+}
+void test_try_lock_two_second_locked()
+{
+    dummy_mutex m1,m2;
+    m2.lock();
+
+    boost::unique_lock<dummy_mutex> l1(m1,boost::defer_lock),
+        l2(m2,boost::defer_lock);
+
+    int const res=boost::try_lock(l1,l2);
+    
+    BOOST_CHECK(res==1);
+    BOOST_CHECK(!m1.is_locked);
+    BOOST_CHECK(m2.is_locked);
+    BOOST_CHECK(!l1.owns_lock());
+    BOOST_CHECK(!l2.owns_lock());
+}
+
+void test_try_lock_three()
+{
+    int const num_mutexes=3;
+    
+    for(int i=-1;i<num_mutexes;++i)
+    {
+        dummy_mutex mutexes[num_mutexes];
+
+        if(i>=0)
+        {
+            mutexes[i].lock();
+        }
+        boost::unique_lock<dummy_mutex> l1(mutexes[0],boost::defer_lock),
+            l2(mutexes[1],boost::defer_lock),
+            l3(mutexes[2],boost::defer_lock);
+
+        int const res=boost::try_lock(l1,l2,l3);
+    
+        BOOST_CHECK(res==i);
+        for(int j=0;j<num_mutexes;++j)
+        {
+            if((i==j) || (i==-1))
+            {
+                BOOST_CHECK(mutexes[j].is_locked);
+            }
+            else
+            {
+                BOOST_CHECK(!mutexes[j].is_locked);
+            }
+        }
+        if(i==-1)
+        {
+            BOOST_CHECK(l1.owns_lock());
+            BOOST_CHECK(l2.owns_lock());
+            BOOST_CHECK(l3.owns_lock());
+        }
+        else
+        {
+            BOOST_CHECK(!l1.owns_lock());
+            BOOST_CHECK(!l2.owns_lock());
+            BOOST_CHECK(!l3.owns_lock());
+        }
+    }
+}
+
+void test_try_lock_four()
+{
+    int const num_mutexes=4;
+    
+    for(int i=-1;i<num_mutexes;++i)
+    {
+        dummy_mutex mutexes[num_mutexes];
+
+        if(i>=0)
+        {
+            mutexes[i].lock();
+        }
+        boost::unique_lock<dummy_mutex> l1(mutexes[0],boost::defer_lock),
+            l2(mutexes[1],boost::defer_lock),
+            l3(mutexes[2],boost::defer_lock),
+            l4(mutexes[3],boost::defer_lock);
+
+        int const res=boost::try_lock(l1,l2,l3,l4);
+    
+        BOOST_CHECK(res==i);
+        for(int j=0;j<num_mutexes;++j)
+        {
+            if((i==j) || (i==-1))
+            {
+                BOOST_CHECK(mutexes[j].is_locked);
+            }
+            else
+            {
+                BOOST_CHECK(!mutexes[j].is_locked);
+            }
+        }
+        if(i==-1)
+        {
+            BOOST_CHECK(l1.owns_lock());
+            BOOST_CHECK(l2.owns_lock());
+            BOOST_CHECK(l3.owns_lock());
+            BOOST_CHECK(l4.owns_lock());
+        }
+        else
+        {
+            BOOST_CHECK(!l1.owns_lock());
+            BOOST_CHECK(!l2.owns_lock());
+            BOOST_CHECK(!l3.owns_lock());
+            BOOST_CHECK(!l4.owns_lock());
+        }
+    }
+}
+
+void test_try_lock_five()
+{
+    int const num_mutexes=5;
+    
+    for(int i=-1;i<num_mutexes;++i)
+    {
+        dummy_mutex mutexes[num_mutexes];
+
+        if(i>=0)
+        {
+            mutexes[i].lock();
+        }
+        boost::unique_lock<dummy_mutex> l1(mutexes[0],boost::defer_lock),
+            l2(mutexes[1],boost::defer_lock),
+            l3(mutexes[2],boost::defer_lock),
+            l4(mutexes[3],boost::defer_lock),
+            l5(mutexes[4],boost::defer_lock);
+
+        int const res=boost::try_lock(l1,l2,l3,l4,l5);
+    
+        BOOST_CHECK(res==i);
+        for(int j=0;j<num_mutexes;++j)
+        {
+            if((i==j) || (i==-1))
+            {
+                BOOST_CHECK(mutexes[j].is_locked);
+            }
+            else
+            {
+                BOOST_CHECK(!mutexes[j].is_locked);
+            }
+        }
+        if(i==-1)
+        {
+            BOOST_CHECK(l1.owns_lock());
+            BOOST_CHECK(l2.owns_lock());
+            BOOST_CHECK(l3.owns_lock());
+            BOOST_CHECK(l4.owns_lock());
+            BOOST_CHECK(l5.owns_lock());
+        }
+        else
+        {
+            BOOST_CHECK(!l1.owns_lock());
+            BOOST_CHECK(!l2.owns_lock());
+            BOOST_CHECK(!l3.owns_lock());
+            BOOST_CHECK(!l4.owns_lock());
+            BOOST_CHECK(!l5.owns_lock());
+        }
+    }
+}
+
+
+
+boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
+{
+    boost::unit_test_framework::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Fiber: generic locks test suite");
+
+    test->add(BOOST_TEST_CASE(&test_lock_two_uncontended));
+    test->add(BOOST_TEST_CASE(&test_lock_two_other_thread_locks_in_order));
+    test->add(BOOST_TEST_CASE(&test_lock_two_other_thread_locks_in_opposite_order));
+    test->add(BOOST_TEST_CASE(&test_lock_five_uncontended));
+    test->add(BOOST_TEST_CASE(&test_lock_five_other_thread_locks_in_order));
+    test->add(BOOST_TEST_CASE(&test_lock_five_other_thread_locks_in_different_order));
+    test->add(BOOST_TEST_CASE(&test_lock_five_in_range));
+    test->add(BOOST_TEST_CASE(&test_lock_ten_in_range));
+    test->add(BOOST_TEST_CASE(&test_lock_ten_other_thread_locks_in_different_order));
+    test->add(BOOST_TEST_CASE(&test_try_lock_two_uncontended));
+    test->add(BOOST_TEST_CASE(&test_try_lock_two_first_locked));
+    test->add(BOOST_TEST_CASE(&test_try_lock_two_second_locked));
+    test->add(BOOST_TEST_CASE(&test_try_lock_three));
+    test->add(BOOST_TEST_CASE(&test_try_lock_four));
+    test->add(BOOST_TEST_CASE(&test_try_lock_five));
+
+    return test;
+}

Added: sandbox/fiber/libs/fiber/test/test_manual_reset_event.cpp
==============================================================================
--- (empty file)
+++ sandbox/fiber/libs/fiber/test/test_manual_reset_event.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -0,0 +1,158 @@
+
+//          Copyright Oliver Kowalke 2009.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/function.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/fiber.hpp>
+
+int value = 0;
+
+void wait_fn( boost::fiber::manual_reset_event & ev)
+{
+	ev.wait();
+	++value;
+}
+
+void test_case_1()
+{
+	value = 0;
+	boost::fiber::manual_reset_event ev;
+	boost::fiber::scheduler sched;
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	ev.set();
+
+	while ( sched.run() );
+
+	BOOST_CHECK( ! sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 0), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+}
+
+void test_case_2()
+{
+	value = 0;
+	boost::fiber::manual_reset_event ev;
+	boost::fiber::scheduler sched;
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	ev.set();
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	ev.reset();
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value);
+
+	ev.set();
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK( ! sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 0), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+}
+
+void test_case_3()
+{
+	value = 0;
+	boost::fiber::manual_reset_event ev( true);
+	boost::fiber::scheduler sched;
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	sched.make_fiber(
+		wait_fn,
+		boost::ref( ev) );
+
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 0, value);
+
+	while ( sched.run() );
+
+	BOOST_CHECK( ! sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 0), sched.size() );
+	BOOST_CHECK_EQUAL( 2, value);
+}
+
+void test_case_4()
+{
+	boost::fiber::manual_reset_event ev;
+
+	BOOST_CHECK_EQUAL( false, ev.try_wait() );
+
+	ev.set();
+
+	BOOST_CHECK_EQUAL( true, ev.try_wait() );
+	BOOST_CHECK_EQUAL( true, ev.try_wait() );
+
+	ev.reset();
+
+	BOOST_CHECK_EQUAL( false, ev.try_wait() );
+}
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+	boost::unit_test::test_suite * test =
+		BOOST_TEST_SUITE("Boost.Fiber: manual-reset-event test suite");
+
+	test->add( BOOST_TEST_CASE( & test_case_1) );
+	test->add( BOOST_TEST_CASE( & test_case_2) );
+	test->add( BOOST_TEST_CASE( & test_case_3) );
+	test->add( BOOST_TEST_CASE( & test_case_4) );
+
+	return test;
+}

Modified: sandbox/fiber/libs/fiber/test/test_mutex.cpp
==============================================================================
--- sandbox/fiber/libs/fiber/test/test_mutex.cpp	(original)
+++ sandbox/fiber/libs/fiber/test/test_mutex.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -17,13 +17,10 @@
 #include <boost/function.hpp>
 #include <boost/ref.hpp>
 #include <boost/test/unit_test.hpp>
-#include <boost/thread.hpp>
 #include <boost/utility.hpp>
 
 #include <boost/fiber.hpp>
 
-#include <libs/task/test/util.ipp>
-
 template< typename M >
 struct test_lock
 {
@@ -65,19 +62,80 @@
     test_lock< boost::fiber::mutex >()();
 }
 
-void test_mutex()
+void test_case1()
 {
         boost::fiber::scheduler sched;
     sched.make_fiber( & do_test_mutex);
         sched.run();
 }
 
+int value1 = 0;
+int value2 = 0;
+
+void test_fn1( boost::fiber::mutex & mtx)
+{
+	boost::fiber::mutex::scoped_lock lk( mtx);
+	++value1;
+	for ( int i = 0; i < 3; ++i)
+		boost::this_fiber::yield();
+}
+
+void test_fn2( boost::fiber::mutex & mtx)
+{
+	boost::fiber::mutex::scoped_lock lk( mtx);
+	++value2;
+}
+
+void test_case2()
+{
+	boost::fiber::mutex mtx;
+	boost::fiber::scheduler sched;
+    sched.make_fiber( & test_fn1, boost::ref( mtx) );
+    sched.make_fiber( & test_fn2, boost::ref( mtx) );
+
+	BOOST_CHECK_EQUAL( 0, value1);
+	BOOST_CHECK_EQUAL( 0, value2);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value1);
+	BOOST_CHECK_EQUAL( 0, value2);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value1);
+	BOOST_CHECK_EQUAL( 0, value2);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value1);
+	BOOST_CHECK_EQUAL( 0, value2);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 2), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value1);
+	BOOST_CHECK_EQUAL( 0, value2);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 1), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value1);
+	BOOST_CHECK_EQUAL( 0, value2);
+
+	BOOST_CHECK( sched.run() );
+	BOOST_CHECK_EQUAL( std::size_t( 0), sched.size() );
+	BOOST_CHECK_EQUAL( 1, value1);
+	BOOST_CHECK_EQUAL( 1, value2);
+}
+
 boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
 {
     boost::unit_test_framework::test_suite * test =
                 BOOST_TEST_SUITE("Boost.Fiber: mutex test suite");
 
-    test->add(BOOST_TEST_CASE(&test_mutex));
+    test->add(BOOST_TEST_CASE(&test_case1));
+    test->add(BOOST_TEST_CASE(&test_case2));
 
         return test;
 }

Added: sandbox/fiber/libs/fiber/test/test_unique_lock.cpp
==============================================================================
--- (empty file)
+++ sandbox/fiber/libs/fiber/test/test_unique_lock.cpp	2009-11-09 13:27:32 EST (Mon, 09 Nov 2009)
@@ -0,0 +1,200 @@
+
+//          Copyright Oliver Kowalke 2009.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// This test is based on the tests of Boost.Thread 
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <boost/ref.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/utility.hpp>
+
+#include <boost/fiber.hpp>
+
+struct dummy_mutex
+{
+	bool is_locked;
+	
+	dummy_mutex() :
+	    is_locked( false)
+	{}
+	
+	void lock()
+	{ is_locked = true; }
+	
+	bool try_lock()
+	{
+	    if ( is_locked)
+	        return false;
+	    is_locked = true;
+	    return true;
+	}
+	
+	void unlock()
+	{ is_locked = false; }
+};
+
+void test_lock()
+{
+	boost::fiber::mutex mtx;
+	boost::fiber::unique_lock< boost::fiber::mutex > lk( mtx);
+
+	BOOST_CHECK( lk);
+	BOOST_CHECK( lk.owns_lock() );
+
+	lk.unlock();
+
+	BOOST_CHECK( ! lk);
+	BOOST_CHECK( ! lk.owns_lock() );
+}
+
+void test_defer_lock()
+{
+	boost::fiber::mutex mtx;
+	boost::fiber::unique_lock< boost::fiber::mutex > lk( mtx, boost::defer_lock);
+
+	BOOST_CHECK( ! lk);
+	BOOST_CHECK( ! lk.owns_lock() );
+
+	lk.lock();
+
+	BOOST_CHECK( lk);
+	BOOST_CHECK( lk.owns_lock() );
+}
+
+void test_adopt_lock()
+{
+	boost::fiber::mutex mtx;
+	mtx.lock();
+	boost::fiber::unique_lock< boost::fiber::mutex > lk( mtx, boost::adopt_lock);
+
+	BOOST_CHECK( lk);
+	BOOST_CHECK( lk.owns_lock() );
+}
+
+void test_try_lock()
+{
+	boost::fiber::mutex mtx;
+	boost::fiber::unique_lock< boost::fiber::mutex > lk( mtx, boost::defer_lock);
+
+	BOOST_CHECK( ! lk);
+	BOOST_CHECK( ! lk.owns_lock() );
+
+	lk.try_lock();
+
+	BOOST_CHECK( lk);
+	BOOST_CHECK( lk.owns_lock() );
+}
+
+void test_lock_twice()
+{
+	boost::fiber::mutex mtx;
+	boost::fiber::unique_lock< boost::fiber::mutex > lk( mtx);
+
+	BOOST_CHECK_THROW( lk.lock(), boost::fiber::lock_error);
+}
+
+void test_try_lock_twice()
+{
+	boost::fiber::mutex mtx;
+	boost::fiber::unique_lock< boost::fiber::mutex > lk( mtx);
+
+	BOOST_CHECK_THROW( lk.try_lock(), boost::fiber::lock_error);
+}
+
+void test_unlock_twice()
+{
+	boost::fiber::mutex mtx;
+	boost::fiber::unique_lock< boost::fiber::mutex > lk( mtx);
+	lk.unlock();
+
+	BOOST_CHECK_THROW( lk.unlock(), boost::fiber::lock_error);
+}
+
+void test_default_ctor()
+{
+	boost::fiber::unique_lock< boost::fiber::mutex > lk;
+
+	BOOST_CHECK( ! lk);
+	BOOST_CHECK( ! lk.owns_lock() );
+}
+
+void test_lock_concept()
+{
+    boost::fiber::mutex mtx1, mtx2, mtx3;
+
+    boost::fiber::mutex::scoped_lock lk1( mtx1, boost::defer_lock),
+        lk2( mtx2, boost::defer_lock),
+        lk3( mtx3, boost::defer_lock);
+
+    BOOST_CHECK( ! lk1.owns_lock() );
+    BOOST_CHECK( ! lk2.owns_lock() );
+    BOOST_CHECK( ! lk3.owns_lock() );
+    
+    boost::lock( lk1, lk2, lk3);
+    
+    BOOST_CHECK( lk1.owns_lock() );
+    BOOST_CHECK( lk2.owns_lock() );
+    BOOST_CHECK( lk3.owns_lock() );
+}
+
+void test_try_lock_concept()
+{
+    dummy_mutex mtx1, mtx2;
+    mtx2.lock();
+
+    boost::fiber::unique_lock< dummy_mutex > lk1( mtx1, boost::defer_lock),
+        lk2( mtx2, boost::defer_lock);
+
+    int res = boost::try_lock( lk1, lk2);
+    
+    BOOST_CHECK( res == 1);
+    BOOST_CHECK( ! mtx1.is_locked);
+    BOOST_CHECK( mtx2.is_locked);
+    BOOST_CHECK( ! lk1.owns_lock() );
+    BOOST_CHECK( ! lk2.owns_lock() );
+}
+
+void test_swap()
+{
+	boost::fiber::mutex mtx1, mtx2;
+	
+	boost::fiber::unique_lock< boost::fiber::mutex > lk1( mtx1), lk2( mtx2);
+	
+	BOOST_CHECK_EQUAL( lk1.mutex(), & mtx1);
+	BOOST_CHECK_EQUAL( lk2.mutex(), & mtx2);
+	
+	lk1.swap( lk2);
+	
+	BOOST_CHECK_EQUAL( lk1.mutex(), & mtx2);
+	BOOST_CHECK_EQUAL( lk2.mutex(), & mtx1);
+}
+
+boost::unit_test::test_suite * init_unit_test_suite( int, char* [])
+{
+    boost::unit_test_framework::test_suite * test =
+		BOOST_TEST_SUITE("Boost.Fiber: lock test suite");
+
+    test->add( BOOST_TEST_CASE( & test_lock) );
+    test->add( BOOST_TEST_CASE( & test_defer_lock) );
+    test->add( BOOST_TEST_CASE( & test_adopt_lock) );
+    test->add( BOOST_TEST_CASE( & test_try_lock) );
+    test->add( BOOST_TEST_CASE( & test_lock_twice) );
+    test->add( BOOST_TEST_CASE( & test_try_lock_twice) );
+    test->add( BOOST_TEST_CASE( & test_unlock_twice) );
+    test->add( BOOST_TEST_CASE( & test_default_ctor) );
+    test->add( BOOST_TEST_CASE( & test_lock_concept) );
+    test->add( BOOST_TEST_CASE( & test_try_lock_concept) );
+    test->add( BOOST_TEST_CASE( & test_swap) );
+
+	return test;
+}