ceph/src/boost/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 int p1()
  27 {
  28   BOOST_THREAD_LOG << "p1 < " << BOOST_THREAD_END_LOG;
  29   boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  30   BOOST_THREAD_LOG << "p1 >"  << BOOST_THREAD_END_LOG;
  31   return 1;
  32 }
  33
  34 int p2(boost::shared_future<int> f)
  35 {
  36   BOOST_THREAD_LOG << "p2 <" << &f << BOOST_THREAD_END_LOG;
  37   BOOST_TEST(f.valid());
  38   int i = f.get();
  39   boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  40   BOOST_THREAD_LOG << "p2 <" << &f << BOOST_THREAD_END_LOG;
  41   return 2 * i;
  42 }
  43
  44 void p3(boost::shared_future<int> f)
  45 {
  46   BOOST_THREAD_LOG << "p3 <" << &f << BOOST_THREAD_END_LOG;
  47   BOOST_TEST(f.valid());
  48   int i = f.get();
  49   boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  50   BOOST_THREAD_LOG << "p3 <" << &f << " " << i << BOOST_THREAD_END_LOG;
  51   return ;
  52 }
  53
  54 int main()
  55 {
  56   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
  57   {
  58     boost::basic_thread_pool ex(1);
  59     boost::shared_future<int> f1 = boost::async(boost::launch::async, &p1).share();
  60     BOOST_TEST(f1.valid());
  61     boost::future<int> f2 = f1.then(ex, &p2);
  62     BOOST_TEST(f2.valid());
  63     try
  64     {
  65       BOOST_TEST(f2.get()==2);
  66     }
  67     catch (std::exception& ex)
  68     {
  69       BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
  70       BOOST_TEST(false);
  71     }
  72     catch (...)
  73     {
  74       BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
  75       BOOST_TEST(false);
  76     }
  77   }
  78   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
  79   {
  80     boost::basic_thread_pool ex(1);
  81     boost::shared_future<int> f1 = boost::async(boost::launch::async, &p1).share();
  82     BOOST_TEST(f1.valid());
  83     boost::future<void> f2 = f1.then(ex, &p3);
  84     BOOST_TEST(f2.valid());
  85     try
  86     {
  87       f2.wait();
  88     }
  89     catch (std::exception& ex)
  90     {
  91       BOOST_THREAD_LOG << "ERRORRRRR "<<ex.what() << "" << BOOST_THREAD_END_LOG;
  92       BOOST_TEST(false);
  93     }
  94     catch (...)
  95     {
  96       BOOST_THREAD_LOG << " ERRORRRRR exception thrown" << BOOST_THREAD_END_LOG;
  97       BOOST_TEST(false);
  98     }
  99   }
 100   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 101   {
 102     boost::basic_thread_pool ex(1);
 103     boost::future<int> f2 = boost::async(p1).share().then(ex, &p2);
 104     BOOST_TEST(f2.get()==2);
 105   }
 106   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 107   {
 108     boost::basic_thread_pool ex(1);
 109     boost::shared_future<int> f1 = boost::async(p1).share();
 110     boost::shared_future<int> f21 = f1.then(ex, &p2).share();
 111     boost::future<int> f2= f21.then(ex, &p2);
 112     BOOST_TEST(f2.get()==4);
 113   }
 114   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 115   {
 116     boost::basic_thread_pool ex(1);
 117     boost::shared_future<int> f1 = boost::async(p1).share();
 118     boost::shared_future<int> f21 = f1.then(ex, &p2).share();
 119     boost::future<int> f2= f21.then(&p2);
 120     BOOST_TEST(f2.get()==4);
 121   }
 122   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 123   {
 124     boost::basic_thread_pool ex(1);
 125     boost::shared_future<int> f1 = boost::async(p1).share();
 126     boost::future<int> f2= f1.then(ex, &p2).share().then(ex, &p2);
 127     BOOST_TEST(f2.get()==4);
 128   }
 129   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 130   {
 131     boost::basic_thread_pool ex(1);
 132     boost::future<int> f2 = boost::async(p1).share().then(ex, &p2).share().then(ex, &p2);
 133     BOOST_TEST(f2.get()==4);
 134   }
 135
 136   return boost::report_errors();
 137 }
 138
 139 #else
 140
 141 int main()
 142 {
 143   return 0;
 144 }
 145 #endif