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