ceph/src/boost/libs/thread/test/sync/futures/future/get_or_pass.cpp

   1 // Copyright (C) 2013 Vicente J. Botet Escriba
   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 // R future::get_or(R&&);
  11 // R& future<R&>::get_or(R&);
  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/thread/thread.hpp>
  20 #include <boost/core/ref.hpp>
  21 #include <boost/detail/lightweight_test.hpp>
  22
  23 #if defined BOOST_THREAD_USES_CHRONO
  24
  25 namespace boost
  26 {
  27 template <typename T>
  28 struct wrap
  29 {
  30   wrap(T const& v) : value(v){}
  31   T value;
  32
  33 };
  34
  35 template <typename T>
  36 exception_ptr make_exception_ptr(T v) {
  37   return copy_exception(wrap<T>(v));
  38 }
  39 }
  40
  41 void func1(boost::promise<int> p)
  42 {
  43     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  44     p.set_value(3);
  45 }
  46
  47 void func2(boost::promise<int> p)
  48 {
  49     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  50     p.set_exception(boost::make_exception_ptr(3));
  51 }
  52
  53 int j = 0;
  54
  55 void func3(boost::promise<int&> p)
  56 {
  57     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  58     j = 5;
  59     p.set_value(j);
  60 }
  61
  62 void func4(boost::promise<int&> p)
  63 {
  64     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  65     p.set_exception(boost::make_exception_ptr(3.5));
  66 }
  67
  68 void func5(boost::promise<void> p)
  69 {
  70     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  71     p.set_value();
  72 }
  73
  74 void func6(boost::promise<void> p)
  75 {
  76     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  77     p.set_exception(boost::make_exception_ptr(4));
  78 }
  79
  80
  81 int main()
  82 {
  83   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
  84   {
  85       typedef int T;
  86       {
  87           boost::promise<T> p;
  88           boost::future<T> f = p.get_future();
  89 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
  90            boost::thread(func1, boost::move(p)).detach();
  91 #else
  92            p.set_value(3);
  93 #endif
  94           BOOST_TEST(f.valid());
  95           BOOST_TEST(f.get_or(4) == 3);
  96 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
  97           BOOST_TEST(!f.valid());
  98 #endif
  99       }
 100       BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 101       {
 102           boost::promise<T> p;
 103           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 104           boost::future<T> f = p.get_future();
 105           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 106 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 107           boost::thread(func2, boost::move(p)).detach();
 108 #else
 109           p.set_exception(boost::make_exception_ptr(3));
 110 #endif
 111           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 112           try
 113           {
 114             BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 115               BOOST_TEST(f.valid());
 116               BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 117               BOOST_TEST(f.get_or(4) == 4);
 118               BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 119           }
 120           catch (...)
 121           {
 122             BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 123             BOOST_TEST(false);
 124           }
 125 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 126           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 127           BOOST_TEST(!f.valid());
 128 #endif
 129           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 130       }
 131   }
 132   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 133   {
 134       typedef int& T;
 135       {
 136           boost::promise<T> p;
 137           boost::future<T> f = p.get_future();
 138 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 139           boost::thread(func3, boost::move(p)).detach();
 140 #else
 141           int j=5;
 142           p.set_value(j);
 143 #endif
 144           BOOST_TEST(f.valid());
 145           int k=4;
 146           BOOST_TEST(f.get_or(boost::ref(k)) == 5);
 147 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 148           BOOST_TEST(!f.valid());
 149 #endif
 150       }
 151       BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 152       {
 153           boost::promise<T> p;
 154           boost::future<T> f = p.get_future();
 155 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 156           boost::thread(func4, boost::move(p)).detach();
 157 #else
 158           p.set_exception(boost::make_exception_ptr(3.5));
 159 #endif
 160           try
 161           {
 162               BOOST_TEST(f.valid());
 163               int j=4;
 164               BOOST_TEST(f.get_or(boost::ref(j)) == 4);
 165           }
 166           catch (...)
 167           {
 168             BOOST_TEST(false);
 169           }
 170 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 171           BOOST_TEST(!f.valid());
 172 #endif
 173       }
 174   }
 175   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 176
 177
 178   return boost::report_errors();
 179 }
 180
 181 #else
 182 #error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
 183 #endif