ceph/src/boost/libs/thread/test/sync/futures/promise/move_ctor_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 // <future>
  16
  17 // class promise<R>
  18
  19 // promise(promise&& rhs);
  20
  21 #define BOOST_THREAD_VERSION 3
  22
  23 #include <boost/thread/future.hpp>
  24 #include <boost/detail/lightweight_test.hpp>
  25 #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
  26 #include "../test_allocator.hpp"
  27 #endif
  28
  29 boost::mutex m;
  30
  31 int main()
  32 {
  33 #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
  34   BOOST_TEST(test_alloc_base::count == 0);
  35   {
  36     boost::promise<int> p0(boost::allocator_arg, test_allocator<int>());
  37     boost::promise<int> p(boost::move(p0));
  38     BOOST_TEST(test_alloc_base::count == 1);
  39     std::cout << __LINE__ << std::endl;
  40     boost::future<int> f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
  41     std::cout << __LINE__ << std::endl;
  42     BOOST_TEST(test_alloc_base::count == 1);
  43     BOOST_TEST(f.valid());
  44     std::cout << __LINE__ << std::endl;
  45     try
  46     {
  47       f = BOOST_THREAD_MAKE_RV_REF(p0.get_future());
  48       BOOST_TEST(false);
  49     }
  50     catch (const boost::future_error& e)
  51     {
  52       BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
  53     }
  54     std::cout << __LINE__ << std::endl;
  55     BOOST_TEST(test_alloc_base::count == 1);
  56   }
  57   std::cout << __LINE__ << std::endl;
  58   BOOST_TEST(test_alloc_base::count == 0);
  59   {
  60     boost::promise<int&> p0(boost::allocator_arg, test_allocator<int>());
  61     boost::promise<int&> p(boost::move(p0));
  62     BOOST_TEST(test_alloc_base::count == 1);
  63     boost::future<int&> f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
  64     BOOST_TEST(test_alloc_base::count == 1);
  65     BOOST_TEST(f.valid());
  66     try
  67     {
  68       f = BOOST_THREAD_MAKE_RV_REF(p0.get_future());
  69       BOOST_TEST(false);
  70     }
  71     catch (const boost::future_error& e)
  72     {
  73       BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
  74     }
  75     BOOST_TEST(test_alloc_base::count == 1);
  76   }
  77   BOOST_TEST(test_alloc_base::count == 0);
  78   {
  79     boost::promise<void> p0(boost::allocator_arg, test_allocator<void>());
  80     boost::promise<void> p(boost::move(p0));
  81     BOOST_TEST(test_alloc_base::count == 1);
  82     boost::future<void> f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
  83     BOOST_TEST(test_alloc_base::count == 1);
  84     BOOST_TEST(f.valid());
  85     try
  86     {
  87       f = BOOST_THREAD_MAKE_RV_REF(p0.get_future());
  88       BOOST_TEST(false);
  89     }
  90     catch (const boost::future_error& e)
  91     {
  92       BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
  93     }
  94     BOOST_TEST(test_alloc_base::count == 1);
  95   }
  96   BOOST_TEST(test_alloc_base::count == 0);
  97 #endif
  98   {
  99     boost::promise<int> p0;
 100     boost::promise<int> p(boost::move(p0));
 101     std::cout << __LINE__ << std::endl;
 102     boost::future<int> f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
 103     std::cout << __LINE__ << std::endl;
 104     BOOST_TEST(f.valid());
 105     std::cout << __LINE__ << std::endl;
 106     try
 107     {
 108       f = BOOST_THREAD_MAKE_RV_REF(p0.get_future());
 109       BOOST_TEST(false);
 110     }
 111     catch (const boost::future_error& e)
 112     {
 113       BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
 114     }
 115     std::cout << __LINE__ << std::endl;
 116   }
 117   std::cout << __LINE__ << std::endl;
 118   {
 119     boost::promise<int&> p0;
 120     boost::promise<int&> p(boost::move(p0));
 121     boost::future<int&> f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
 122     BOOST_TEST(f.valid());
 123     try
 124     {
 125       f = BOOST_THREAD_MAKE_RV_REF(p0.get_future());
 126       BOOST_TEST(false);
 127     }
 128     catch (const boost::future_error& e)
 129     {
 130       BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
 131     }
 132   }
 133   {
 134     boost::promise<void> p0;
 135     boost::promise<void> p(boost::move(p0));
 136     boost::future<void> f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
 137     BOOST_TEST(f.valid());
 138     try
 139     {
 140       f = BOOST_THREAD_MAKE_RV_REF(p0.get_future());
 141       BOOST_TEST(false);
 142     }
 143     catch (const boost::future_error& e)
 144     {
 145       BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::no_state));
 146     }
 147   }
 148
 149   return boost::report_errors();
 150 }
 151