ceph/src/boost/libs/thread/test/sync/futures/shared_future/then_pass.cpp

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