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

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // Copyright (C) 2011 Vicente J. Botet Escriba
  11 //
  12 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  13 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  14
  15 // <boost/thread/future.hpp>
  16
  17 // class future<R>
  18
  19 // const R& future::get();
  20 // R& future<R&>::get();
  21 // void future<void>::get();
  22
  23 //#define BOOST_THREAD_VERSION 3
  24 #define BOOST_THREAD_VERSION 4
  25 //#define BOOST_THREAD_USES_LOG
  26 #define BOOST_THREAD_USES_LOG_THREAD_ID
  27 #include <boost/thread/detail/log.hpp>
  28
  29 #include <boost/thread/future.hpp>
  30 #include <boost/thread/thread.hpp>
  31 #include <boost/detail/lightweight_test.hpp>
  32
  33 #if defined BOOST_THREAD_USES_CHRONO
  34
  35 namespace boost
  36 {
  37 template <typename T>
  38 struct wrap
  39 {
  40   wrap(T const& v) : value(v){}
  41   T value;
  42
  43 };
  44
  45 template <typename T>
  46 exception_ptr make_exception_ptr(T v) {
  47   return copy_exception(wrap<T>(v));
  48 }
  49 }
  50
  51 void func1(boost::promise<int> p)
  52 {
  53     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  54     p.set_value(3);
  55 }
  56
  57 void func2(boost::promise<int> p)
  58 {
  59     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  60     p.set_exception(boost::make_exception_ptr(3));
  61 }
  62
  63 int j = 0;
  64
  65 void func3(boost::promise<int&> p)
  66 {
  67     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  68     j = 5;
  69     p.set_value(j);
  70 }
  71
  72 void func4(boost::promise<int&> p)
  73 {
  74     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  75     p.set_exception(boost::make_exception_ptr(3.5));
  76 }
  77
  78 void func5(boost::promise<void> p)
  79 {
  80     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  81     p.set_value();
  82 }
  83
  84 void func6(boost::promise<void> p)
  85 {
  86     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
  87     p.set_exception(boost::make_exception_ptr(4));
  88 }
  89
  90
  91 int main()
  92 {
  93   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
  94   {
  95       typedef int T;
  96       {
  97           boost::promise<T> p;
  98           boost::future<T> f = p.get_future();
  99 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 100            boost::thread(func1, boost::move(p)).detach();
 101 #else
 102            p.set_value(3);
 103 #endif
 104           BOOST_TEST(f.valid());
 105           BOOST_TEST(f.get() == 3);
 106 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 107           BOOST_TEST(!f.valid());
 108 #endif
 109       }
 110       BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 111       {
 112           boost::promise<T> p;
 113           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 114           boost::future<T> f = p.get_future();
 115           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 116 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 117           boost::thread(func2, boost::move(p)).detach();
 118 #else
 119           p.set_exception(boost::make_exception_ptr(3));
 120 #endif
 121           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 122           try
 123           {
 124             BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 125               BOOST_TEST(f.valid());
 126               BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 127               BOOST_TEST(f.get() == 3);
 128               BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 129               BOOST_TEST(false);
 130               BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 131           }
 132           catch (boost::wrap<int> const& i)
 133           {
 134             BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 135               BOOST_TEST(i.value == 3);
 136               BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 137           }
 138           catch (...)
 139           {
 140             BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 141               BOOST_TEST(false);
 142               BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 143           }
 144 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 145           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 146           BOOST_TEST(!f.valid());
 147 #endif
 148           BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 149       }
 150   }
 151   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 152   {
 153       typedef int& T;
 154       {
 155           boost::promise<T> p;
 156           boost::future<T> f = p.get_future();
 157 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 158           boost::thread(func3, boost::move(p)).detach();
 159 #else
 160           int j=5;
 161           p.set_value(j);
 162 #endif
 163           BOOST_TEST(f.valid());
 164           BOOST_TEST(f.get() == 5);
 165 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 166           BOOST_TEST(!f.valid());
 167 #endif
 168       }
 169       BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 170       {
 171           boost::promise<T> p;
 172           boost::future<T> f = p.get_future();
 173 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 174           boost::thread(func4, boost::move(p)).detach();
 175 #else
 176           p.set_exception(boost::make_exception_ptr(3.5));
 177 #endif
 178           try
 179           {
 180               BOOST_TEST(f.valid());
 181               BOOST_TEST(f.get() == 3);
 182               BOOST_TEST(false);
 183           }
 184           catch (boost::wrap<double> const& i)
 185           {
 186               BOOST_TEST(i.value == 3.5);
 187           }
 188 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 189           BOOST_TEST(!f.valid());
 190 #endif
 191       }
 192       BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 193       {
 194           boost::promise<T> p;
 195           boost::future<T> f = p.get_future();
 196 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 197           boost::thread(func4, boost::move(p)).detach();
 198 #else
 199           p.set_exception(boost::make_exception_ptr(3.5));
 200 #endif
 201           try
 202           {
 203               BOOST_TEST(f.valid());
 204               boost::exception_ptr ptr = f.get_exception_ptr();
 205           }
 206           catch (...)
 207           {
 208             BOOST_TEST(false);
 209           }
 210           BOOST_TEST(f.valid());
 211       }
 212   }
 213   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 214
 215   typedef void T;
 216   {
 217       boost::promise<T> p;
 218       boost::future<T> f = p.get_future();
 219 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 220        boost::thread(func5, boost::move(p)).detach();
 221 #else
 222        p.set_value();
 223 #endif
 224       BOOST_TEST(f.valid());
 225       f.get();
 226 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 227       BOOST_TEST(!f.valid());
 228 #endif
 229   }
 230   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 231   {
 232       boost::promise<T> p;
 233       boost::future<T> f = p.get_future();
 234 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 235       boost::thread(func6, boost::move(p)).detach();
 236 #else
 237       p.set_exception(boost::make_exception_ptr(4));
 238 #endif
 239       try
 240       {
 241           BOOST_TEST(f.valid());
 242           f.get();
 243           BOOST_TEST(false);
 244       }
 245       catch (boost::wrap<int> const& i)
 246       {
 247           BOOST_TEST(i.value == 4);
 248       }
 249       catch (...)
 250       {
 251           BOOST_TEST(false);
 252       }
 253 #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
 254       BOOST_TEST(!f.valid());
 255 #endif
 256   }
 257   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 258
 259   return boost::report_errors();
 260 }
 261
 262 #else
 263 #error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
 264 #endif