ceph/src/boost/libs/thread/test/sync/futures/future/wait_until_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) 2013 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 // template <class Rep, class Period>
  20 //   future_status
  21 //   wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
  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/chrono/chrono_io.hpp>
  32 #include <boost/detail/lightweight_test.hpp>
  33
  34 #if defined BOOST_THREAD_USES_CHRONO
  35
  36 typedef boost::chrono::milliseconds ms;
  37
  38 namespace boost
  39 {
  40   template <typename OStream>
  41   OStream& operator<<(OStream& os , boost::future_status st )
  42   {
  43     os << underlying_cast<int>(st) << " ";
  44     return os;
  45   }
  46   template <typename T>
  47   struct wrap
  48   {
  49     wrap(T const& v) :
  50       value(v)
  51     {
  52     }
  53     T value;
  54
  55   };
  56
  57   template <typename T>
  58   exception_ptr make_exception_ptr(T v)
  59   {
  60     return copy_exception(wrap<T> (v));
  61   }
  62 }
  63
  64 void func1(boost::promise<int> p)
  65 {
  66   boost::this_thread::sleep_for(ms(500));
  67   p.set_value(3);
  68 }
  69
  70 int j = 0;
  71
  72 void func3(boost::promise<int&> p)
  73 {
  74   boost::this_thread::sleep_for(ms(500));
  75   j = 5;
  76   p.set_value(j);
  77 }
  78
  79 void func5(boost::promise<void> p)
  80 {
  81   boost::this_thread::sleep_for(ms(500));
  82   p.set_value();
  83 }
  84
  85 int main()
  86 {
  87   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
  88   {
  89     typedef boost::chrono::high_resolution_clock Clock;
  90     {
  91       typedef int T;
  92       boost::promise<T> p;
  93       boost::future<T> f = p.get_future();
  94 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
  95       boost::thread(func1, boost::move(p)).detach();
  96 #endif
  97       BOOST_TEST(f.valid());
  98       BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(300)) , boost::future_status::timeout);
  99 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 100 #else
 101       func1(boost::move(p));
 102 #endif
 103       BOOST_TEST(f.valid());
 104       BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(300)) , boost::future_status::ready);
 105       BOOST_TEST(f.valid());
 106       Clock::time_point t0 = Clock::now();
 107       f.wait();
 108       Clock::time_point t1 = Clock::now();
 109       BOOST_TEST(f.valid());
 110       BOOST_TEST(t1 - t0 < ms(50));
 111     }
 112     {
 113       typedef int& T;
 114       boost::promise<T> p;
 115       boost::future<T> f = p.get_future();
 116 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 117       boost::thread(func3, boost::move(p)).detach();
 118 #endif
 119       BOOST_TEST(f.valid());
 120       BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(300)) , boost::future_status::timeout);
 121       BOOST_TEST(f.valid());
 122 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 123 #else
 124       func3(boost::move(p));
 125 #endif
 126       BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(300)) , boost::future_status::ready);
 127       BOOST_TEST(f.valid());
 128       Clock::time_point t0 = Clock::now();
 129       f.wait();
 130       Clock::time_point t1 = Clock::now();
 131       BOOST_TEST(f.valid());
 132       BOOST_TEST(t1 - t0 < ms(50));
 133     }
 134     {
 135       typedef void T;
 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(func5, boost::move(p)).detach();
 140 #endif
 141       BOOST_TEST(f.valid());
 142       BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(300)) , boost::future_status::timeout);
 143       BOOST_TEST(f.valid());
 144 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 145 #else
 146       func5(boost::move(p));
 147 #endif
 148       BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(300)) , boost::future_status::ready);
 149       BOOST_TEST(f.valid());
 150       Clock::time_point t0 = Clock::now();
 151       f.wait();
 152       Clock::time_point t1 = Clock::now();
 153       BOOST_TEST(f.valid());
 154       BOOST_TEST(t1 - t0 < ms(50));
 155     }
 156   }
 157   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 158
 159   return boost::report_errors();
 160 }
 161
 162 #else
 163 #error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
 164 #endif