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