libs/thread/test/sync/futures/shared_future/then_executor_pass.cpp

   1 // Copyright (C) 2014 Vicente Botet
   2 //
   3 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 // <boost/thread/future.hpp>
   7
   8 // class future<R>
   9
  10 // template<typename F>
  11 // auto then(F&& func) -> future<decltype(func(*this))>;
  12
  13 #define BOOST_THREAD_VERSION 4
  14 #define BOOST_THREAD_PROVIDES_EXECUTORS
  15 //#define BOOST_THREAD_USES_LOG
  16 #define BOOST_THREAD_USES_LOG_THREAD_ID
  17 #include <boost/thread/detail/log.hpp>
  18
  19 #include <boost/thread/future.hpp>
  20 #include <boost/thread/executors/basic_thread_pool.hpp>
  21 #include <boost/thread/executor.hpp>
  22 #include <boost/detail/lightweight_test.hpp>
  23
  24 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
  25
  26 #ifdef BOOST_MSVC
  27 #pragma warning(disable: 4127) // conditional expression is constant
  28 #endif
  29
  30 int p1()
  31 {
  32   BOOST_THREAD_LOG << "p1 < " << BOOST_THREAD_END_LOG;
  33   boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  34   BOOST_THREAD_LOG << "p1 >"  << BOOST_THREAD_END_LOG;
  35   return 1;
  36 }
  37
  38 int p2(boost::shared_future<int> f)
  39 {
  40   BOOST_THREAD_LOG << "p2 <" << &f << BOOST_THREAD_END_LOG;
  41   BOOST_TEST(f.valid());
  42   int i = f.get();
  43   boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  44   BOOST_THREAD_LOG << "p2 <" << &f << BOOST_THREAD_END_LOG;
  45   return 2 * i;
  46 }
  47
  48 void p3(boost::shared_future<int> f)
  49 {
  50   BOOST_THREAD_LOG << "p3 <" << &f << BOOST_THREAD_END_LOG;
  51   BOOST_TEST(f.valid());
  52   int i = f.get();
  53   boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  54   BOOST_THREAD_LOG << "p3 <" << &f << " " << i << BOOST_THREAD_END_LOG;
  55   return ;
  56 }
  57
  58 int main()
  59 {
  60   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
  61   {
  62     boost::basic_thread_pool ex(1);
  63     boost::shared_future<int> f1 = boost::async(boost::launch::async, &p1).share();
  64     BOOST_TEST(f1.valid());
  65     boost::future<int> f2 = f1.then(ex, &p2);
  66     BOOST_TEST(f2.valid());
  67     try
  68     {
  69       BOOST_TEST(f2.get()==2);
  70     }
  71     catch (std::exception& ex)
  72     {
  73       BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
  74       BOOST_TEST(false);
  75     }
  76     catch (...)
  77     {
  78       BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
  79       BOOST_TEST(false);
  80     }
  81   }
  82   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
  83   {
  84     boost::basic_thread_pool ex(1);
  85     boost::shared_future<int> f1 = boost::async(boost::launch::async, &p1).share();
  86     BOOST_TEST(f1.valid());
  87     boost::future<void> f2 = f1.then(ex, &p3);
  88     BOOST_TEST(f2.valid());
  89     try
  90     {
  91       f2.wait();
  92     }
  93     catch (std::exception& ex)
  94     {
  95       BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
  96       BOOST_TEST(false);
  97     }
  98     catch (...)
  99     {
 100       BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
 101       BOOST_TEST(false);
 102     }
 103   }
 104   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 105   {
 106     boost::basic_thread_pool ex(1);
 107     boost::future<int> f2 = boost::async(p1).share().then(ex, &p2);
 108     BOOST_TEST(f2.get()==2);
 109   }
 110   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 111   {
 112     boost::basic_thread_pool ex(1);
 113     boost::shared_future<int> f1 = boost::async(p1).share();
 114     boost::shared_future<int> f21 = f1.then(ex, &p2).share();
 115     boost::future<int> f2= f21.then(ex, &p2);
 116     BOOST_TEST(f2.get()==4);
 117   }
 118   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 119   {
 120     boost::basic_thread_pool ex(1);
 121     boost::shared_future<int> f1 = boost::async(p1).share();
 122     boost::shared_future<int> f21 = f1.then(ex, &p2).share();
 123     boost::future<int> f2= f21.then(&p2);
 124     BOOST_TEST(f2.get()==4);
 125   }
 126   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 127   {
 128     boost::basic_thread_pool ex(1);
 129     boost::shared_future<int> f1 = boost::async(p1).share();
 130     boost::future<int> f2= f1.then(ex, &p2).share().then(ex, &p2);
 131     BOOST_TEST(f2.get()==4);
 132   }
 133   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 134   {
 135     boost::basic_thread_pool ex(1);
 136     boost::future<int> f2 = boost::async(p1).share().then(ex, &p2).share().then(ex, &p2);
 137     BOOST_TEST(f2.get()==4);
 138   }
 139
 140   return boost::report_errors();
 141 }
 142
 143 #else
 144
 145 int main()
 146 {
 147   return 0;
 148 }
 149 #endif