[Boost-commit] svn:boost r53894 - in sandbox/task: boost/task libs/task/test

Subject: [Boost-commit] svn:boost r53894 - in sandbox/task: boost/task libs/task/test
From: oliver.kowalke_at_[hidden]
Date: 2009-06-14 03:57:31

Author: olli
Date: 2009-06-14 03:57:30 EDT (Sun, 14 Jun 2009)
New Revision: 53894
URL: http://svn.boost.org/trac/boost/changeset/53894

Log:
* test for futures added

Added:
   sandbox/task/libs/task/test/test_futures.cpp   (contents, props changed)
Text files modified: 
   sandbox/task/boost/task/future.hpp     |     4 ----                                    
   sandbox/task/libs/task/test/Jamfile.v2 |     1 +                                       
   2 files changed, 1 insertions(+), 4 deletions(-)

Modified: sandbox/task/boost/task/future.hpp
==============================================================================
--- sandbox/task/boost/task/future.hpp	(original)
+++ sandbox/task/boost/task/future.hpp	2009-06-14 03:57:30 EDT (Sun, 14 Jun 2009)
@@ -1358,10 +1358,6 @@
         }
         
     };
-	
-	template< typename T >
-	detail::thread_move_t< packaged_task< T > > move( packaged_task< T > & t)
-	{ return detail::thread_move_t< packaged_task< T > >( t); }
 }
 
 #endif

Modified: sandbox/task/libs/task/test/Jamfile.v2
==============================================================================
--- sandbox/task/libs/task/test/Jamfile.v2	(original)
+++ sandbox/task/libs/task/test/Jamfile.v2	2009-06-14 03:57:30 EDT (Sun, 14 Jun 2009)
@@ -25,6 +25,7 @@
 }
 
 test-suite task :
+    [ task-test test_futures ]
     [ task-test test_own_thread ]
     [ task-test test_new_thread ]
     [ task-test test_default_pool ]

Added: sandbox/task/libs/task/test/test_futures.cpp
==============================================================================
--- (empty file)
+++ sandbox/task/libs/task/test/test_futures.cpp	2009-06-14 03:57:30 EDT (Sun, 14 Jun 2009)
@@ -0,0 +1,758 @@
+//  (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/thread.hpp"
+#include "boost/thread/mutex.hpp"
+#include "boost/thread/condition.hpp"
+#include "boost/task/future.hpp"
+#include <assert.h>
+#include <utility>
+#include <memory>
+#include <string>
+
+#ifdef BOOST_HAS_RVALUE_REFS
+    template<typename T>
+    typename boost::remove_reference<T>::type&& move(T&& t)
+    {
+        return t;
+    }
+#else
+    template<typename T>
+    boost::detail::thread_move_t<T> move(T& t)
+    {
+        return boost::move(t);
+    }
+#endif
+
+struct X
+{
+private:
+    
+    X(X& other);
+    
+public:
+    
+    int i;
+    
+    X():
+        i(42)
+    {}
+#ifdef BOOST_HAS_RVALUE_REFS
+    X(X&& other):
+        i(other.i)
+    {
+        other.i=0;
+    }
+#else
+    X(boost::detail::thread_move_t<X> other):
+        i(other->i)
+    {
+        other->i=0;
+    }
+    operator boost::detail::thread_move_t<X>()
+    {
+        return boost::detail::thread_move_t<X>(*this);
+    }
+#endif
+    ~X()
+    {}
+};
+
+int make_int()
+{
+    return 42;
+}
+
+int throw_runtime_error()
+{
+    throw std::runtime_error("42");
+}
+
+void set_promise_thread(boost::promise<int>* p)
+{
+    p->set_value(42);
+}
+
+struct my_exception
+{};
+
+void set_promise_exception_thread(boost::promise<int>* p)
+{
+    p->set_exception(boost::copy_exception(my_exception()));
+}
+
+
+void test_store_value_from_thread()
+{
+    boost::promise<int> pi2;
+    boost::unique_future<int> fi2=pi2.get_future();
+    boost::thread(set_promise_thread,&pi2);
+    int j=fi2.get();
+    assert(j==42);
+    assert(fi2.is_ready());
+    assert(fi2.has_value());
+    assert(!fi2.has_exception());
+    assert(fi2.get_state()==boost::future_state::ready);
+}
+
+
+void test_store_exception()
+{
+    boost::promise<int> pi3;
+    boost::unique_future<int> fi3=pi3.get_future();
+    boost::thread(set_promise_exception_thread,&pi3);
+    try
+    {
+        fi3.get();
+        assert(false);
+    }
+    catch(my_exception)
+    {
+        assert(true);
+    }
+    
+    assert(fi3.is_ready());
+    assert(!fi3.has_value());
+    assert(fi3.has_exception());
+    assert(fi3.get_state()==boost::future_state::ready);
+}
+
+void test_initial_state()
+{
+    boost::unique_future<int> fi;
+    assert(!fi.is_ready());
+    assert(!fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::uninitialized);
+    int i;
+    try
+    {
+        i=fi.get();
+        assert(false);
+    }
+    catch(boost::future_uninitialized)
+    {
+        assert(true);
+    }
+}
+
+void test_waiting_future()
+{
+    boost::promise<int> pi;
+    boost::unique_future<int> fi;
+    fi=pi.get_future();
+
+    int i=0;
+    assert(!fi.is_ready());
+    assert(!fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::waiting);
+    assert(i==0);
+}
+
+void test_cannot_get_future_twice()
+{
+    boost::promise<int> pi;
+    pi.get_future();
+
+    try
+    {
+        pi.get_future();
+        assert(false);
+    }
+    catch(boost::future_already_retrieved&)
+    {
+        assert(true);
+    }
+}
+
+void test_set_value_updates_future_state()
+{
+    boost::promise<int> pi;
+    boost::unique_future<int> fi;
+    fi=pi.get_future();
+
+    pi.set_value(42);
+    
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+}
+
+void test_set_value_can_be_retrieved()
+{
+    boost::promise<int> pi;
+    boost::unique_future<int> fi;
+    fi=pi.get_future();
+
+    pi.set_value(42);
+    
+    int i=0;
+    assert(i=fi.get());
+    assert(i==42);
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+}
+
+void test_set_value_can_be_moved()
+{
+//     boost::promise<int> pi;
+//     boost::unique_future<int> fi;
+//     fi=pi.get_future();
+
+//     pi.set_value(42);
+    
+//     int i=0;
+//     assert(i=fi.get());
+//     assert(i==42);
+//     assert(fi.is_ready());
+//     assert(fi.has_value());
+//     assert(!fi.has_exception());
+//     assert(fi.get_state()==boost::future_state::ready);
+}
+
+void test_future_from_packaged_task_is_waiting()
+{
+    boost::packaged_task<int> pt(make_int);
+    boost::unique_future<int> fi=pt.get_future();
+    int i=0;
+    assert(!fi.is_ready());
+    assert(!fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::waiting);
+    assert(i==0);
+}
+
+void test_invoking_a_packaged_task_populates_future()
+{
+    boost::packaged_task<int> pt(make_int);
+    boost::unique_future<int> fi=pt.get_future();
+
+    pt();
+
+    int i=0;
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+    assert(i=fi.get());
+    assert(i==42);
+}
+
+void test_invoking_a_packaged_task_twice_throws()
+{
+    boost::packaged_task<int> pt(make_int);
+
+    pt();
+    try
+    {
+        pt();
+        assert(false);
+    }
+    catch(boost::task_already_started)
+    {
+        assert(true);
+    }
+}
+
+
+void test_cannot_get_future_twice_from_task()
+{
+    boost::packaged_task<int> pt(make_int);
+    pt.get_future();
+    try
+    {
+        pt.get_future();
+        assert(false);
+    }
+    catch(boost::future_already_retrieved)
+    {
+        assert(true);
+    }
+}
+
+void test_task_stores_exception_if_function_throws()
+{
+    boost::packaged_task<int> pt(throw_runtime_error);
+    boost::unique_future<int> fi=pt.get_future();
+
+    pt();
+
+    int i=0;
+    assert(fi.is_ready());
+    assert(!fi.has_value());
+    assert(fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+    try
+    {
+        fi.get();
+        assert(false);
+    }
+    catch(std::exception&)
+    {
+        assert(true);
+    }
+    catch(...)
+    {
+        assert(!"Unknown exception thrown");
+    }
+    
+}
+
+void test_void_promise()
+{
+    boost::promise<void> p;
+    boost::unique_future<void> f=p.get_future();
+    p.set_value();
+    assert(f.is_ready());
+    assert(f.has_value());
+    assert(!f.has_exception());
+    assert(f.get_state()==boost::future_state::ready);
+    f.get();
+}
+
+void test_reference_promise()
+{
+    boost::promise<int&> p;
+    boost::unique_future<int&> f=p.get_future();
+    int i=42;
+    p.set_value(i);
+    assert(f.is_ready());
+    assert(f.has_value());
+    assert(!f.has_exception());
+    assert(f.get_state()==boost::future_state::ready);
+    assert(&f.get()==&i);
+}
+
+void do_nothing()
+{}
+
+void test_task_returning_void()
+{
+    boost::packaged_task<void> pt(do_nothing);
+    boost::unique_future<void> fi=pt.get_future();
+
+    pt();
+
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+}
+
+int global_ref_target=0;
+
+int& return_ref()
+{
+    return global_ref_target;
+}
+
+void test_task_returning_reference()
+{
+    boost::packaged_task<int&> pt(return_ref);
+    boost::unique_future<int&> fi=pt.get_future();
+
+    pt();
+
+    assert(fi.is_ready());
+    assert(fi.has_value());
+    assert(!fi.has_exception());
+    assert(fi.get_state()==boost::future_state::ready);
+    int& i=fi.get();
+    assert(&i==&global_ref_target);
+}
+
+void test_shared_future()
+{
+    boost::packaged_task<int> pt(make_int);
+    boost::unique_future<int> fi=pt.get_future();
+
+    boost::shared_future<int> sf(boost::move(fi));
+    assert(fi.get_state()==boost::future_state::uninitialized);
+
+    pt();
+
+    int i=0;
+    assert(sf.is_ready());
+    assert(sf.has_value());
+    assert(!sf.has_exception());
+    assert(sf.get_state()==boost::future_state::ready);
+    assert(i=sf.get());
+    assert(i==42);
+}
+
+void test_copies_of_shared_future_become_ready_together()
+{
+    boost::packaged_task<int> pt(make_int);
+    boost::unique_future<int> fi=pt.get_future();
+
+    boost::shared_future<int> sf(boost::move(fi));
+    boost::shared_future<int> sf2(sf);
+    boost::shared_future<int> sf3;
+    sf3=sf;
+    assert(sf.get_state()==boost::future_state::waiting);
+    assert(sf2.get_state()==boost::future_state::waiting);
+    assert(sf3.get_state()==boost::future_state::waiting);
+
+    pt();
+
+    int i=0;
+    assert(sf.is_ready());
+    assert(sf.has_value());
+    assert(!sf.has_exception());
+    assert(sf.get_state()==boost::future_state::ready);
+    assert(i=sf.get());
+    assert(i==42);
+    i=0;
+    assert(sf2.is_ready());
+    assert(sf2.has_value());
+    assert(!sf2.has_exception());
+    assert(sf2.get_state()==boost::future_state::ready);
+    assert(i=sf2.get());
+    assert(i==42);
+    i=0;
+    assert(sf3.is_ready());
+    assert(sf3.has_value());
+    assert(!sf3.has_exception());
+    assert(sf3.get_state()==boost::future_state::ready);
+    assert(i=sf3.get());
+    assert(i==42);
+}
+
+void test_shared_future_can_be_move_assigned_from_unique_future()
+{
+    boost::packaged_task<int> pt(make_int);
+    boost::unique_future<int> fi=pt.get_future();
+
+    boost::shared_future<int> sf;
+    sf=boost::move(fi);
+    assert(fi.get_state()==boost::future_state::uninitialized);
+
+    int i=0;
+    assert(!sf.is_ready());
+    assert(!sf.has_value());
+    assert(!sf.has_exception());
+    assert(sf.get_state()==boost::future_state::waiting);
+}
+
+void test_shared_future_void()
+{
+    boost::packaged_task<void> pt(do_nothing);
+    boost::unique_future<void> fi=pt.get_future();
+
+    boost::shared_future<void> sf(boost::move(fi));
+    assert(fi.get_state()==boost::future_state::uninitialized);
+
+    pt();
+
+    assert(sf.is_ready());
+    assert(sf.has_value());
+    assert(!sf.has_exception());
+    assert(sf.get_state()==boost::future_state::ready);
+    sf.get();
+}
+
+void test_shared_future_ref()
+{
+    boost::promise<int&> p;
+    boost::shared_future<int&> f(p.get_future());
+    int i=42;
+    p.set_value(i);
+    assert(f.is_ready());
+    assert(f.has_value());
+    assert(!f.has_exception());
+    assert(f.get_state()==boost::future_state::ready);
+    assert(&f.get()==&i);
+}
+
+void test_can_get_a_second_future_from_a_moved_promise()
+{
+    boost::promise<int> pi;
+    boost::unique_future<int> fi=pi.get_future();
+    
+    boost::promise<int> pi2(boost::move(pi));
+    boost::unique_future<int> fi2=pi.get_future();
+
+    pi2.set_value(3);
+    assert(fi.is_ready());
+    assert(!fi2.is_ready());
+    assert(fi.get()==3);
+    pi.set_value(42);
+    assert(fi2.is_ready());
+    assert(fi2.get()==42);
+}
+
+void test_can_get_a_second_future_from_a_moved_void_promise()
+{
+    boost::promise<void> pi;
+    boost::unique_future<void> fi=pi.get_future();
+    
+    boost::promise<void> pi2(boost::move(pi));
+    boost::unique_future<void> fi2=pi.get_future();
+
+    pi2.set_value();
+    assert(fi.is_ready());
+    assert(!fi2.is_ready());
+    pi.set_value();
+    assert(fi2.is_ready());
+}
+
+void test_unique_future_for_move_only_udt()
+{
+    boost::promise<X> pt;
+    boost::unique_future<X> fi=pt.get_future();
+
+    pt.set_value(X());
+    X res(fi.get());
+    assert(res.i==42);
+}
+
+void test_unique_future_for_string()
+{
+    boost::promise<std::string> pt;
+    boost::unique_future<std::string> fi=pt.get_future();
+
+    pt.set_value(std::string("hello"));
+    std::string res(fi.get());
+    assert(res=="hello");
+
+    boost::promise<std::string> pt2;
+    fi=pt2.get_future();
+
+    std::string const s="goodbye";
+    
+    pt2.set_value(s);
+    res=fi.get();
+    assert(res=="goodbye");
+
+    boost::promise<std::string> pt3;
+    fi=pt3.get_future();
+
+    std::string s2="foo";
+    
+    pt3.set_value(s2);
+    res=fi.get();
+    assert(res=="foo");
+}
+
+boost::mutex callback_mutex;
+unsigned callback_called=0;
+
+void wait_callback(boost::promise<int>& pi)
+{
+    boost::lock_guard<boost::mutex> lk(callback_mutex);
+    ++callback_called;
+    try
+    {
+        pi.set_value(42);
+    }
+    catch(...)
+    {
+    }
+}
+
+void do_nothing_callback(boost::promise<int>& pi)
+{
+    boost::lock_guard<boost::mutex> lk(callback_mutex);
+    ++callback_called;
+}
+
+void test_wait_callback()
+{
+    callback_called=0;
+    boost::promise<int> pi;
+    boost::unique_future<int> fi=pi.get_future();
+    pi.set_wait_callback(wait_callback);
+    fi.wait();
+    assert(callback_called);
+    assert(fi.get()==42);
+    fi.wait();
+    fi.wait();
+    assert(callback_called==1);
+}
+
+void test_wait_callback_with_timed_wait()
+{
+    callback_called=0;
+    boost::promise<int> pi;
+    boost::unique_future<int> fi=pi.get_future();
+    pi.set_wait_callback(do_nothing_callback);
+    bool success=fi.timed_wait(boost::posix_time::milliseconds(10));
+    assert(callback_called);
+    assert(!success);
+    success=fi.timed_wait(boost::posix_time::milliseconds(10));
+    assert(!success);
+    success=fi.timed_wait(boost::posix_time::milliseconds(10));
+    assert(!success);
+    assert(callback_called==3);
+    pi.set_value(42);
+    success=fi.timed_wait(boost::posix_time::milliseconds(10));
+    assert(success);
+    assert(callback_called==3);
+    assert(fi.get()==42);
+    assert(callback_called==3);
+}
+
+void test_wait_callback_with_timed_wait_until()
+{
+    callback_called=0;
+    boost::promise<int> pi;
+    boost::unique_future<int> fi=pi.get_future();
+    pi.set_wait_callback(do_nothing_callback);
+    bool success=fi.timed_wait_until(boost::get_system_time() + boost::posix_time::milliseconds(10));
+    assert(callback_called);
+    assert(!success);
+    success=fi.timed_wait_until(boost::get_system_time() + boost::posix_time::milliseconds(10));
+    assert(!success);
+    success=fi.timed_wait_until(boost::get_system_time() + boost::posix_time::milliseconds(10));
+    assert(!success);
+    assert(callback_called==3);
+    pi.set_value(42);
+    success=fi.timed_wait_until(boost::get_system_time() + boost::posix_time::milliseconds(10));
+    assert(success);
+    assert(callback_called==3);
+    assert(fi.get()==42);
+    assert(callback_called==3);
+}
+
+
+void wait_callback_for_task(boost::packaged_task<int>& pt)
+{
+    boost::lock_guard<boost::mutex> lk(callback_mutex);
+    ++callback_called;
+    try
+    {
+        pt();
+    }
+    catch(...)
+    {
+    }
+}
+
+
+void test_wait_callback_for_packaged_task()
+{
+    callback_called=0;
+    boost::packaged_task<int> pt(make_int);
+    boost::unique_future<int> fi=pt.get_future();
+    pt.set_wait_callback(wait_callback_for_task);
+    fi.wait();
+    assert(callback_called);
+    assert(fi.get()==42);
+    fi.wait();
+    fi.wait();
+    assert(callback_called==1);
+}
+
+void test_packaged_task_can_be_moved()
+{
+    boost::packaged_task<int> pt(make_int);
+
+    boost::unique_future<int> fi=pt.get_future();
+
+    assert(!fi.is_ready());
+    
+    boost::packaged_task<int> pt2=boost::move(pt);
+    assert(!fi.is_ready());
+    try
+    {
+        pt();
+        assert(!"Can invoke moved task!");
+    }
+    catch(boost::task_moved&)
+    {
+    }
+
+    assert(!fi.is_ready());
+
+    pt2();
+    
+    assert(fi.is_ready());
+}
+
+void test_destroying_a_promise_stores_broken_promise()
+{
+    boost::unique_future<int> f;
+    
+    {
+        boost::promise<int> p;
+        f=p.get_future();
+    }
+    assert(f.is_ready());
+    assert(f.has_exception());
+    try
+    {
+        f.get();
+    }
+    catch(boost::broken_promise&)
+    {
+    }
+}
+
+void test_destroying_a_packaged_task_stores_broken_promise()
+{
+    boost::unique_future<int> f;
+    
+    {
+        boost::packaged_task<int> p(make_int);
+        f=p.get_future();
+    }
+    assert(f.is_ready());
+    assert(f.has_exception());
+    try
+    {
+        f.get();
+    }
+    catch(boost::broken_promise&)
+    {
+    }
+}
+
+int make_int_slowly()
+{
+    boost::this_thread::sleep(boost::posix_time::seconds(1));
+    return 42;
+}
+
+int main()
+{
+    test_initial_state();
+    test_waiting_future();
+    test_cannot_get_future_twice();
+   test_set_value_updates_future_state();
+   test_set_value_can_be_retrieved();
+   test_set_value_can_be_moved();
+   test_store_value_from_thread();
+   test_store_exception();
+   test_future_from_packaged_task_is_waiting();
+   test_invoking_a_packaged_task_populates_future();
+   test_invoking_a_packaged_task_twice_throws();
+   test_cannot_get_future_twice_from_task();
+   test_task_stores_exception_if_function_throws();
+   test_void_promise();
+   test_reference_promise();
+   test_task_returning_void();
+   test_task_returning_reference();
+   test_shared_future();
+   test_copies_of_shared_future_become_ready_together();
+  test_shared_future_can_be_move_assigned_from_unique_future();
+  test_shared_future_void();
+  test_shared_future_ref();
+   test_can_get_a_second_future_from_a_moved_promise();
+   test_can_get_a_second_future_from_a_moved_void_promise();
+   test_unique_future_for_move_only_udt();
+   test_unique_future_for_string();
+   test_wait_callback();
+   test_wait_callback_with_timed_wait();
+   test_wait_callback_with_timed_wait_until();
+   test_wait_callback_for_packaged_task();
+   test_packaged_task_can_be_moved();
+   test_destroying_a_promise_stores_broken_promise();
+   test_destroying_a_packaged_task_stores_broken_promise();
+}