]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // (C) Copyright 2008-10 Anthony Williams |
2 | // 2015 Oliver Kowalke | |
3 | // | |
4 | // Distributed under the Boost Software License, Version 1.0. (See | |
5 | // accompanying file LICENSE_1_0.txt or copy at | |
6 | // http://www.boost.org/LICENSE_1_0.txt) | |
7 | ||
8 | #include <chrono> | |
9 | #include <memory> | |
10 | #include <stdexcept> | |
11 | #include <string> | |
12 | #include <utility> | |
13 | ||
14 | #include <boost/test/unit_test.hpp> | |
15 | ||
16 | #include <boost/fiber/all.hpp> | |
17 | ||
18 | typedef std::chrono::milliseconds ms; | |
19 | typedef std::chrono::high_resolution_clock Clock; | |
20 | ||
21 | int gi = 7; | |
22 | ||
23 | struct my_exception : public std::runtime_error { | |
24 | my_exception() : | |
25 | std::runtime_error("my_exception") { | |
26 | } | |
27 | }; | |
28 | ||
29 | struct A { | |
30 | A() = default; | |
31 | ||
32 | A( A const&) = delete; | |
33 | A( A &&) = default; | |
34 | ||
35 | A & operator=( A const&) = delete; | |
36 | A & operator=( A &&) = default; | |
37 | ||
38 | int value; | |
39 | }; | |
40 | ||
41 | void fn1( boost::fibers::promise< int > * p, int i) { | |
42 | boost::this_fiber::yield(); | |
43 | p->set_value( i); | |
44 | } | |
45 | ||
46 | void fn2() { | |
47 | boost::fibers::promise< int > p; | |
48 | boost::fibers::shared_future< int > f( p.get_future().share() ); | |
49 | boost::this_fiber::yield(); | |
50 | boost::fibers::fiber( boost::fibers::launch::post, fn1, & p, 7).detach(); | |
51 | boost::this_fiber::yield(); | |
52 | BOOST_CHECK( 7 == f.get() ); | |
53 | } | |
54 | ||
55 | int fn3() { | |
56 | return 3; | |
57 | } | |
58 | ||
59 | void fn4() { | |
60 | } | |
61 | ||
62 | int fn5() { | |
63 | boost::throw_exception( my_exception() ); | |
64 | return 3; | |
65 | } | |
66 | ||
67 | void fn6() { | |
68 | boost::throw_exception( my_exception() ); | |
69 | } | |
70 | ||
71 | int & fn7() { | |
72 | return gi; | |
73 | } | |
74 | ||
75 | int fn8( int i) { | |
76 | return i; | |
77 | } | |
78 | ||
79 | A fn9() { | |
80 | A a; | |
81 | a.value = 3; | |
82 | return std::move( a); | |
83 | } | |
84 | ||
85 | A fn10() { | |
86 | boost::throw_exception( my_exception() ); | |
87 | return A(); | |
88 | } | |
89 | ||
90 | void fn11( boost::fibers::promise< int > p) { | |
91 | boost::this_fiber::sleep_for( ms(500) ); | |
92 | p.set_value(3); | |
93 | } | |
94 | ||
95 | void fn12( boost::fibers::promise< int& > p) { | |
96 | boost::this_fiber::sleep_for( ms(500) ); | |
97 | gi = 5; | |
98 | p.set_value( gi); | |
99 | } | |
100 | ||
101 | void fn13( boost::fibers::promise< void > p) { | |
102 | boost::this_fiber::sleep_for( ms(500) ); | |
103 | p.set_value(); | |
104 | } | |
105 | ||
106 | // shared_future | |
107 | void test_shared_future_create() { | |
108 | { | |
109 | // default constructed and assigned shared_future is not valid | |
110 | boost::fibers::shared_future< int > f1; | |
111 | boost::fibers::shared_future< int > f2 = f1; | |
112 | BOOST_CHECK( ! f1.valid() ); | |
113 | BOOST_CHECK( ! f2.valid() ); | |
114 | } | |
115 | ||
116 | { | |
117 | // shared_future retrieved from promise is valid | |
118 | boost::fibers::promise< int > p; | |
119 | boost::fibers::shared_future< int > f1 = p.get_future(); | |
120 | boost::fibers::shared_future< int > f2 = f1; | |
121 | BOOST_CHECK( f1.valid() ); | |
122 | BOOST_CHECK( f2.valid() ); | |
123 | } | |
124 | } | |
125 | ||
126 | void test_shared_future_create_ref() { | |
127 | { | |
128 | // default constructed and assigned shared_future is not valid | |
129 | boost::fibers::shared_future< int& > f1; | |
130 | boost::fibers::shared_future< int& > f2 = f1; | |
131 | BOOST_CHECK( ! f1.valid() ); | |
132 | BOOST_CHECK( ! f2.valid() ); | |
133 | } | |
134 | ||
135 | { | |
136 | // shared_future retrieved from promise is valid | |
137 | boost::fibers::promise< int& > p; | |
138 | boost::fibers::shared_future< int& > f1 = p.get_future(); | |
139 | boost::fibers::shared_future< int& > f2 = f1; | |
140 | BOOST_CHECK( f1.valid() ); | |
141 | BOOST_CHECK( f2.valid() ); | |
142 | } | |
143 | } | |
144 | ||
145 | void test_shared_future_create_void() { | |
146 | { | |
147 | // default constructed and assigned shared_future is not valid | |
148 | boost::fibers::shared_future< void > f1; | |
149 | boost::fibers::shared_future< void > f2 = f1; | |
150 | BOOST_CHECK( ! f1.valid() ); | |
151 | BOOST_CHECK( ! f2.valid() ); | |
152 | } | |
153 | ||
154 | { | |
155 | // shared_future retrieved from promise is valid | |
156 | boost::fibers::promise< void > p; | |
157 | boost::fibers::shared_future< void > f1 = p.get_future(); | |
158 | boost::fibers::shared_future< void > f2 = f1; | |
159 | BOOST_CHECK( f1.valid() ); | |
160 | BOOST_CHECK( f2.valid() ); | |
161 | } | |
162 | } | |
163 | ||
164 | void test_shared_future_get() { | |
165 | // future retrieved from promise is valid (if it is the first) | |
166 | boost::fibers::promise< int > p1; | |
167 | p1.set_value( 7); | |
168 | ||
169 | boost::fibers::shared_future< int > f1 = p1.get_future().share(); | |
170 | BOOST_CHECK( f1.valid() ); | |
171 | ||
172 | // get | |
173 | BOOST_CHECK( ! f1.get_exception_ptr() ); | |
174 | BOOST_CHECK( 7 == f1.get() ); | |
175 | BOOST_CHECK( f1.valid() ); | |
176 | ||
177 | // throw broken_promise if promise is destroyed without set | |
178 | { | |
179 | boost::fibers::promise< int > p2; | |
180 | f1 = p2.get_future().share(); | |
181 | } | |
182 | bool thrown = false; | |
183 | try { | |
184 | f1.get(); | |
185 | } catch ( boost::fibers::broken_promise const&) { | |
186 | thrown = true; | |
187 | } | |
188 | BOOST_CHECK( f1.valid() ); | |
189 | BOOST_CHECK( thrown); | |
190 | } | |
191 | ||
192 | void test_shared_future_get_move() { | |
193 | // future retrieved from promise is valid (if it is the first) | |
194 | boost::fibers::promise< A > p1; | |
195 | A a; a.value = 7; | |
196 | p1.set_value( std::move( a) ); | |
197 | ||
198 | boost::fibers::shared_future< A > f1 = p1.get_future().share(); | |
199 | BOOST_CHECK( f1.valid() ); | |
200 | ||
201 | // get | |
202 | BOOST_CHECK( ! f1.get_exception_ptr() ); | |
203 | BOOST_CHECK( 7 == f1.get().value); | |
204 | BOOST_CHECK( f1.valid() ); | |
205 | ||
206 | // throw broken_promise if promise is destroyed without set | |
207 | { | |
208 | boost::fibers::promise< A > p2; | |
209 | f1 = p2.get_future().share(); | |
210 | } | |
211 | bool thrown = false; | |
212 | try { | |
213 | f1.get(); | |
214 | } catch ( boost::fibers::broken_promise const&) { | |
215 | thrown = true; | |
216 | } | |
217 | BOOST_CHECK( f1.valid() ); | |
218 | BOOST_CHECK( thrown); | |
219 | } | |
220 | ||
221 | void test_shared_future_get_ref() { | |
222 | // future retrieved from promise is valid (if it is the first) | |
223 | boost::fibers::promise< int& > p1; | |
224 | int i = 7; | |
225 | p1.set_value( i); | |
226 | ||
227 | boost::fibers::shared_future< int& > f1 = p1.get_future().share(); | |
228 | BOOST_CHECK( f1.valid() ); | |
229 | ||
230 | // get | |
231 | BOOST_CHECK( ! f1.get_exception_ptr() ); | |
232 | int & j = f1.get(); | |
233 | BOOST_CHECK( &i == &j); | |
234 | BOOST_CHECK( f1.valid() ); | |
235 | ||
236 | // throw broken_promise if promise is destroyed without set | |
237 | { | |
238 | boost::fibers::promise< int& > p2; | |
239 | f1 = p2.get_future().share(); | |
240 | } | |
241 | bool thrown = false; | |
242 | try { | |
243 | f1.get(); | |
244 | } catch ( boost::fibers::broken_promise const&) { | |
245 | thrown = true; | |
246 | } | |
247 | BOOST_CHECK( f1.valid() ); | |
248 | BOOST_CHECK( thrown); | |
249 | } | |
250 | ||
251 | ||
252 | void test_shared_future_get_void() { | |
253 | // future retrieved from promise is valid (if it is the first) | |
254 | boost::fibers::promise< void > p1; | |
255 | p1.set_value(); | |
256 | ||
257 | boost::fibers::shared_future< void > f1 = p1.get_future().share(); | |
258 | BOOST_CHECK( f1.valid() ); | |
259 | ||
260 | // get | |
261 | BOOST_CHECK( ! f1.get_exception_ptr() ); | |
262 | f1.get(); | |
263 | BOOST_CHECK( f1.valid() ); | |
264 | ||
265 | // throw broken_promise if promise is destroyed without set | |
266 | { | |
267 | boost::fibers::promise< void > p2; | |
268 | f1 = p2.get_future().share(); | |
269 | } | |
270 | bool thrown = false; | |
271 | try { | |
272 | f1.get(); | |
273 | } catch ( boost::fibers::broken_promise const&) { | |
274 | thrown = true; | |
275 | } | |
276 | BOOST_CHECK( f1.valid() ); | |
277 | BOOST_CHECK( thrown); | |
278 | } | |
279 | ||
280 | void test_future_share() { | |
281 | // future retrieved from promise is valid (if it is the first) | |
282 | boost::fibers::promise< int > p1; | |
283 | int i = 7; | |
284 | p1.set_value( i); | |
285 | ||
286 | boost::fibers::future< int > f1 = p1.get_future(); | |
287 | BOOST_CHECK( f1.valid() ); | |
288 | ||
289 | // share | |
290 | boost::fibers::shared_future< int > sf1 = f1.share(); | |
291 | BOOST_CHECK( sf1.valid() ); | |
292 | BOOST_CHECK( ! f1.valid() ); | |
293 | ||
294 | // get | |
295 | BOOST_CHECK( ! sf1.get_exception_ptr() ); | |
296 | int j = sf1.get(); | |
297 | BOOST_CHECK_EQUAL( i, j); | |
298 | BOOST_CHECK( sf1.valid() ); | |
299 | } | |
300 | ||
301 | void test_future_share_ref() { | |
302 | // future retrieved from promise is valid (if it is the first) | |
303 | boost::fibers::promise< int& > p1; | |
304 | int i = 7; | |
305 | p1.set_value( i); | |
306 | ||
307 | boost::fibers::future< int& > f1 = p1.get_future(); | |
308 | BOOST_CHECK( f1.valid() ); | |
309 | ||
310 | // share | |
311 | boost::fibers::shared_future< int& > sf1 = f1.share(); | |
312 | BOOST_CHECK( sf1.valid() ); | |
313 | BOOST_CHECK( ! f1.valid() ); | |
314 | ||
315 | // get | |
316 | BOOST_CHECK( ! sf1.get_exception_ptr() ); | |
317 | int & j = sf1.get(); | |
318 | BOOST_CHECK( &i == &j); | |
319 | BOOST_CHECK( sf1.valid() ); | |
320 | } | |
321 | ||
322 | void test_future_share_void() { | |
323 | // future retrieved from promise is valid (if it is the first) | |
324 | boost::fibers::promise< void > p1; | |
325 | p1.set_value(); | |
326 | ||
327 | boost::fibers::future< void > f1 = p1.get_future(); | |
328 | BOOST_CHECK( f1.valid() ); | |
329 | ||
330 | // share | |
331 | boost::fibers::shared_future< void > sf1 = f1.share(); | |
332 | BOOST_CHECK( sf1.valid() ); | |
333 | BOOST_CHECK( ! f1.valid() ); | |
334 | ||
335 | // get | |
336 | BOOST_CHECK( ! sf1.get_exception_ptr() ); | |
337 | sf1.get(); | |
338 | BOOST_CHECK( sf1.valid() ); | |
339 | } | |
340 | ||
341 | void test_shared_future_wait() { | |
342 | // future retrieved from promise is valid (if it is the first) | |
343 | boost::fibers::promise< int > p1; | |
344 | boost::fibers::shared_future< int > f1 = p1.get_future().share(); | |
345 | ||
346 | // wait on future | |
347 | p1.set_value( 7); | |
348 | f1.wait(); | |
349 | BOOST_CHECK( 7 == f1.get() ); | |
350 | } | |
351 | ||
352 | void test_shared_future_wait_ref() { | |
353 | // future retrieved from promise is valid (if it is the first) | |
354 | boost::fibers::promise< int& > p1; | |
355 | boost::fibers::shared_future< int& > f1 = p1.get_future().share(); | |
356 | ||
357 | // wait on future | |
358 | int i = 7; | |
359 | p1.set_value( i); | |
360 | f1.wait(); | |
361 | int & j = f1.get(); | |
362 | BOOST_CHECK( &i == &j); | |
363 | } | |
364 | ||
365 | void test_shared_future_wait_void() { | |
366 | // future retrieved from promise is valid (if it is the first) | |
367 | boost::fibers::promise< void > p1; | |
368 | boost::fibers::shared_future< void > f1 = p1.get_future().share(); | |
369 | ||
370 | // wait on future | |
371 | p1.set_value(); | |
372 | f1.wait(); | |
373 | f1.get(); | |
374 | BOOST_CHECK( f1.valid() ); | |
375 | } | |
376 | ||
377 | void test_shared_future_wait_for() { | |
378 | // future retrieved from promise is valid (if it is the first) | |
379 | boost::fibers::promise< int > p1; | |
380 | boost::fibers::shared_future< int > f1 = p1.get_future().share(); | |
381 | ||
382 | boost::fibers::fiber( boost::fibers::launch::post, fn11, std::move( p1) ).detach(); | |
383 | ||
384 | // wait on future | |
385 | BOOST_CHECK( f1.valid() ); | |
386 | boost::fibers::future_status status = f1.wait_for( ms(300) ); | |
387 | BOOST_CHECK( boost::fibers::future_status::timeout == status); | |
388 | ||
389 | BOOST_CHECK( f1.valid() ); | |
390 | status = f1.wait_for( ms(300) ); | |
391 | BOOST_CHECK( boost::fibers::future_status::ready == status); | |
392 | ||
393 | BOOST_CHECK( f1.valid() ); | |
394 | f1.wait(); | |
395 | } | |
396 | ||
397 | void test_shared_future_wait_for_ref() { | |
398 | // future retrieved from promise is valid (if it is the first) | |
399 | boost::fibers::promise< int& > p1; | |
400 | boost::fibers::shared_future< int& > f1 = p1.get_future().share(); | |
401 | ||
402 | boost::fibers::fiber( boost::fibers::launch::post, fn12, std::move( p1) ).detach(); | |
403 | ||
404 | // wait on future | |
405 | BOOST_CHECK( f1.valid() ); | |
406 | boost::fibers::future_status status = f1.wait_for( ms(300) ); | |
407 | BOOST_CHECK( boost::fibers::future_status::timeout == status); | |
408 | ||
409 | BOOST_CHECK( f1.valid() ); | |
410 | status = f1.wait_for( ms(300) ); | |
411 | BOOST_CHECK( boost::fibers::future_status::ready == status); | |
412 | ||
413 | BOOST_CHECK( f1.valid() ); | |
414 | f1.wait(); | |
415 | } | |
416 | ||
417 | void test_shared_future_wait_for_void() { | |
418 | // future retrieved from promise is valid (if it is the first) | |
419 | boost::fibers::promise< void > p1; | |
420 | boost::fibers::shared_future< void > f1 = p1.get_future().share(); | |
421 | ||
422 | boost::fibers::fiber( boost::fibers::launch::post, fn13, std::move( p1) ).detach(); | |
423 | ||
424 | // wait on future | |
425 | BOOST_CHECK( f1.valid() ); | |
426 | boost::fibers::future_status status = f1.wait_for( ms(300) ); | |
427 | BOOST_CHECK( boost::fibers::future_status::timeout == status); | |
428 | ||
429 | BOOST_CHECK( f1.valid() ); | |
430 | status = f1.wait_for( ms(300) ); | |
431 | BOOST_CHECK( boost::fibers::future_status::ready == status); | |
432 | ||
433 | BOOST_CHECK( f1.valid() ); | |
434 | f1.wait(); | |
435 | } | |
436 | ||
437 | void test_shared_future_wait_until() { | |
438 | // future retrieved from promise is valid (if it is the first) | |
439 | boost::fibers::promise< int > p1; | |
440 | boost::fibers::shared_future< int > f1 = p1.get_future().share(); | |
441 | ||
442 | boost::fibers::fiber( boost::fibers::launch::post, fn11, std::move( p1) ).detach(); | |
443 | ||
444 | // wait on future | |
445 | BOOST_CHECK( f1.valid() ); | |
446 | boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) ); | |
447 | BOOST_CHECK( boost::fibers::future_status::timeout == status); | |
448 | ||
449 | BOOST_CHECK( f1.valid() ); | |
450 | status = f1.wait_until( Clock::now() + ms(300) ); | |
451 | BOOST_CHECK( boost::fibers::future_status::ready == status); | |
452 | ||
453 | BOOST_CHECK( f1.valid() ); | |
454 | f1.wait(); | |
455 | } | |
456 | ||
457 | void test_shared_future_wait_until_ref() { | |
458 | // future retrieved from promise is valid (if it is the first) | |
459 | boost::fibers::promise< int& > p1; | |
460 | boost::fibers::shared_future< int& > f1 = p1.get_future().share(); | |
461 | ||
462 | boost::fibers::fiber( boost::fibers::launch::post, fn12, std::move( p1) ).detach(); | |
463 | ||
464 | // wait on future | |
465 | BOOST_CHECK( f1.valid() ); | |
466 | boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) ); | |
467 | BOOST_CHECK( boost::fibers::future_status::timeout == status); | |
468 | ||
469 | BOOST_CHECK( f1.valid() ); | |
470 | status = f1.wait_until( Clock::now() + ms(300) ); | |
471 | BOOST_CHECK( boost::fibers::future_status::ready == status); | |
472 | ||
473 | BOOST_CHECK( f1.valid() ); | |
474 | f1.wait(); | |
475 | } | |
476 | ||
477 | void test_shared_future_wait_until_void() { | |
478 | // future retrieved from promise is valid (if it is the first) | |
479 | boost::fibers::promise< void > p1; | |
480 | boost::fibers::shared_future< void > f1 = p1.get_future().share(); | |
481 | ||
482 | boost::fibers::fiber( boost::fibers::launch::post, fn13, std::move( p1) ).detach(); | |
483 | ||
484 | // wait on future | |
485 | BOOST_CHECK( f1.valid() ); | |
486 | boost::fibers::future_status status = f1.wait_until( Clock::now() + ms(300) ); | |
487 | BOOST_CHECK( boost::fibers::future_status::timeout == status); | |
488 | ||
489 | BOOST_CHECK( f1.valid() ); | |
490 | status = f1.wait_until( Clock::now() + ms(300) ); | |
491 | BOOST_CHECK( boost::fibers::future_status::ready == status); | |
492 | ||
493 | BOOST_CHECK( f1.valid() ); | |
494 | f1.wait(); | |
495 | } | |
496 | ||
497 | void test_shared_future_wait_with_fiber_1() { | |
498 | boost::fibers::promise< int > p1; | |
499 | boost::fibers::fiber( boost::fibers::launch::post, fn1, & p1, 7).detach(); | |
500 | ||
501 | boost::fibers::shared_future< int > f1 = p1.get_future().share(); | |
502 | ||
503 | // wait on future | |
504 | BOOST_CHECK( 7 == f1.get() ); | |
505 | } | |
506 | ||
507 | void test_shared_future_wait_with_fiber_2() { | |
508 | boost::fibers::fiber( boost::fibers::launch::post, fn2).join(); | |
509 | } | |
510 | ||
511 | void test_shared_future_move() { | |
512 | // future retrieved from promise is valid (if it is the first) | |
513 | boost::fibers::promise< int > p1; | |
514 | boost::fibers::shared_future< int > f1 = p1.get_future().share(); | |
515 | BOOST_CHECK( f1.valid() ); | |
516 | ||
517 | // move construction | |
518 | boost::fibers::shared_future< int > f2( std::move( f1) ); | |
519 | BOOST_CHECK( ! f1.valid() ); | |
520 | BOOST_CHECK( f2.valid() ); | |
521 | ||
522 | // move assignment | |
523 | f1 = std::move( f2); | |
524 | BOOST_CHECK( f1.valid() ); | |
525 | BOOST_CHECK( ! f2.valid() ); | |
526 | } | |
527 | ||
528 | void test_shared_future_move_move() { | |
529 | // future retrieved from promise is valid (if it is the first) | |
530 | boost::fibers::promise< A > p1; | |
531 | boost::fibers::shared_future< A > f1 = p1.get_future().share(); | |
532 | BOOST_CHECK( f1.valid() ); | |
533 | ||
534 | // move construction | |
535 | boost::fibers::shared_future< A > f2( std::move( f1) ); | |
536 | BOOST_CHECK( ! f1.valid() ); | |
537 | BOOST_CHECK( f2.valid() ); | |
538 | ||
539 | // move assignment | |
540 | f1 = std::move( f2); | |
541 | BOOST_CHECK( f1.valid() ); | |
542 | BOOST_CHECK( ! f2.valid() ); | |
543 | } | |
544 | ||
545 | void test_shared_future_move_ref() { | |
546 | // future retrieved from promise is valid (if it is the first) | |
547 | boost::fibers::promise< int& > p1; | |
548 | boost::fibers::shared_future< int& > f1 = p1.get_future().share(); | |
549 | BOOST_CHECK( f1.valid() ); | |
550 | ||
551 | // move construction | |
552 | boost::fibers::shared_future< int& > f2( std::move( f1) ); | |
553 | BOOST_CHECK( ! f1.valid() ); | |
554 | BOOST_CHECK( f2.valid() ); | |
555 | ||
556 | // move assignment | |
557 | f1 = std::move( f2); | |
558 | BOOST_CHECK( f1.valid() ); | |
559 | BOOST_CHECK( ! f2.valid() ); | |
560 | } | |
561 | ||
562 | void test_shared_future_move_void() { | |
563 | // future retrieved from promise is valid (if it is the first) | |
564 | boost::fibers::promise< void > p1; | |
565 | boost::fibers::shared_future< void > f1 = p1.get_future().share(); | |
566 | BOOST_CHECK( f1.valid() ); | |
567 | ||
568 | // move construction | |
569 | boost::fibers::shared_future< void > f2( std::move( f1) ); | |
570 | BOOST_CHECK( ! f1.valid() ); | |
571 | BOOST_CHECK( f2.valid() ); | |
572 | ||
573 | // move assignment | |
574 | f1 = std::move( f2); | |
575 | BOOST_CHECK( f1.valid() ); | |
576 | BOOST_CHECK( ! f2.valid() ); | |
577 | } | |
578 | ||
579 | ||
580 | boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[]) { | |
581 | boost::unit_test_framework::test_suite* test = | |
582 | BOOST_TEST_SUITE("Boost.Fiber: shared_future test suite"); | |
583 | ||
584 | test->add(BOOST_TEST_CASE(test_shared_future_create)); | |
585 | test->add(BOOST_TEST_CASE(test_shared_future_create_ref)); | |
586 | test->add(BOOST_TEST_CASE(test_shared_future_create_void)); | |
587 | test->add(BOOST_TEST_CASE(test_shared_future_move)); | |
588 | test->add(BOOST_TEST_CASE(test_shared_future_move_move)); | |
589 | test->add(BOOST_TEST_CASE(test_shared_future_move_ref)); | |
590 | test->add(BOOST_TEST_CASE(test_shared_future_move_void)); | |
591 | test->add(BOOST_TEST_CASE(test_shared_future_get)); | |
592 | test->add(BOOST_TEST_CASE(test_shared_future_get_move)); | |
593 | test->add(BOOST_TEST_CASE(test_shared_future_get_ref)); | |
594 | test->add(BOOST_TEST_CASE(test_shared_future_get_void)); | |
595 | test->add(BOOST_TEST_CASE(test_shared_future_wait)); | |
596 | test->add(BOOST_TEST_CASE(test_shared_future_wait_ref)); | |
597 | test->add(BOOST_TEST_CASE(test_shared_future_wait_void)); | |
598 | test->add(BOOST_TEST_CASE(test_shared_future_wait_for)); | |
599 | test->add(BOOST_TEST_CASE(test_shared_future_wait_for_ref)); | |
600 | test->add(BOOST_TEST_CASE(test_shared_future_wait_for_void)); | |
601 | test->add(BOOST_TEST_CASE(test_shared_future_wait_until)); | |
602 | test->add(BOOST_TEST_CASE(test_shared_future_wait_until_ref)); | |
603 | test->add(BOOST_TEST_CASE(test_shared_future_wait_until_void)); | |
604 | test->add(BOOST_TEST_CASE(test_shared_future_wait_with_fiber_1)); | |
605 | test->add(BOOST_TEST_CASE(test_shared_future_wait_with_fiber_2)); | |
606 | ||
607 | return test; | |
608 | } |