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 // ~future();
20 
21 #define BOOST_THREAD_VERSION 3
22 #include <boost/exception/exception.hpp>
23 
24 #include <boost/thread/future.hpp>
25 #include <boost/detail/lightweight_test.hpp>
26 #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
27 #include "../test_allocator.hpp"
28 #endif
29 
main()30 int main()
31 {
32 #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
33   BOOST_TEST(test_alloc_base::count == 0);
34   {
35       typedef int T;
36       boost::future<T> f;
37       {
38           boost::promise<T> p(boost::allocator_arg, test_allocator<T>());
39           BOOST_TEST(test_alloc_base::count == 1);
40           f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
41           BOOST_TEST(test_alloc_base::count == 1);
42           BOOST_TEST(f.valid());
43       }
44       BOOST_TEST(test_alloc_base::count == 1);
45       BOOST_TEST(f.valid());
46   }
47   BOOST_TEST(test_alloc_base::count == 0);
48   {
49       typedef int& T;
50       boost::future<T> f;
51       {
52           boost::promise<T> p(boost::allocator_arg, test_allocator<int>());
53           BOOST_TEST(test_alloc_base::count == 1);
54           f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
55           BOOST_TEST(test_alloc_base::count == 1);
56           BOOST_TEST(f.valid());
57       }
58       BOOST_TEST(test_alloc_base::count == 1);
59       BOOST_TEST(f.valid());
60   }
61   BOOST_TEST(test_alloc_base::count == 0);
62   {
63       typedef void T;
64       boost::future<T> f;
65       {
66           boost::promise<T> p(boost::allocator_arg, test_allocator<T>());
67           BOOST_TEST(test_alloc_base::count == 1);
68           f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
69           BOOST_TEST(test_alloc_base::count == 1);
70           BOOST_TEST(f.valid());
71       }
72       BOOST_TEST(test_alloc_base::count == 1);
73       BOOST_TEST(f.valid());
74   }
75   BOOST_TEST(test_alloc_base::count == 0);
76 #endif
77   {
78       typedef int T;
79       boost::future<T> f;
80       {
81           boost::promise<T> p;
82           f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
83           BOOST_TEST(f.valid());
84       }
85       BOOST_TEST(f.valid());
86   }
87   {
88       typedef int& T;
89       boost::future<T> f;
90       {
91           boost::promise<T> p;
92           f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
93           BOOST_TEST(f.valid());
94       }
95       BOOST_TEST(f.valid());
96   }
97   {
98       typedef void T;
99       boost::future<T> f;
100       {
101           boost::promise<T> p;
102           f = BOOST_THREAD_MAKE_RV_REF(p.get_future());
103           BOOST_TEST(f.valid());
104       }
105       BOOST_TEST(f.valid());
106   }
107   return boost::report_errors();
108 }
109 
110