]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright (C) 2014 Vicente J. Botet Escriba |
2 | // | |
3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
5 | ||
6 | // <boost/thread/sync_queue.hpp> | |
7 | ||
8 | // class sync_queue<T> | |
9 | ||
10 | // sync_queue(); | |
11 | ||
12 | #define BOOST_THREAD_VERSION 4 | |
13 | //#define BOOST_THREAD_QUEUE_DEPRECATE_OLD | |
14 | ||
15 | #include <boost/thread/concurrent_queues/sync_queue.hpp> | |
16 | #include <boost/thread/concurrent_queues/queue_adaptor.hpp> | |
17 | #include <boost/thread/concurrent_queues/queue_views.hpp> | |
18 | ||
19 | #include <boost/detail/lightweight_test.hpp> | |
20 | #include <boost/static_assert.hpp> | |
21 | ||
22 | class non_copyable | |
23 | { | |
24 | int val; | |
25 | public: | |
26 | BOOST_THREAD_MOVABLE_ONLY(non_copyable) | |
27 | non_copyable(int v) : val(v){} | |
28 | non_copyable(BOOST_RV_REF(non_copyable) x): val(x.val) {} | |
29 | non_copyable& operator=(BOOST_RV_REF(non_copyable) x) { val=x.val; return *this; } | |
30 | bool operator==(non_copyable const& x) const {return val==x.val;} | |
31 | template <typename OSTREAM> | |
32 | friend OSTREAM& operator <<(OSTREAM& os, non_copyable const&x ) | |
33 | { | |
34 | os << x.val; | |
35 | return os; | |
36 | } | |
37 | ||
38 | }; | |
39 | ||
40 | #if defined BOOST_NO_CXX11_RVALUE_REFERENCES | |
41 | BOOST_STATIC_ASSERT( ! boost::is_copy_constructible<non_copyable>::value ); | |
42 | BOOST_STATIC_ASSERT( boost::has_move_emulation_enabled<non_copyable>::value ); | |
43 | #endif | |
44 | ||
45 | int main() | |
46 | { | |
47 | ||
48 | { | |
49 | // default queue invariants | |
50 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
51 | boost::queue_back<int> q(sq); | |
52 | BOOST_TEST(q.empty()); | |
53 | BOOST_TEST(! q.full()); | |
54 | BOOST_TEST_EQ(q.size(), 0u); | |
55 | BOOST_TEST(! q.closed()); | |
56 | } | |
57 | { | |
58 | // default queue invariants | |
59 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
60 | boost::queue_front<int> q(sq); | |
61 | BOOST_TEST(q.empty()); | |
62 | BOOST_TEST(! q.full()); | |
63 | BOOST_TEST_EQ(q.size(), 0u); | |
64 | BOOST_TEST(! q.closed()); | |
65 | } | |
66 | ||
67 | ||
68 | { | |
69 | // empty queue try_pull fails | |
70 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
71 | boost::queue_front<int> q(sq); | |
72 | int i; | |
73 | BOOST_TEST( boost::queue_op_status::empty == q.try_pull(i)); | |
74 | BOOST_TEST(q.empty()); | |
75 | BOOST_TEST(! q.full()); | |
76 | BOOST_TEST_EQ(q.size(), 0u); | |
77 | BOOST_TEST(! q.closed()); | |
78 | } | |
79 | { | |
80 | // empty queue push rvalue/copyable succeeds | |
81 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
82 | boost::queue_back<int> q(sq); | |
83 | q.push(1); | |
84 | BOOST_TEST(! q.empty()); | |
85 | BOOST_TEST(! q.full()); | |
86 | BOOST_TEST_EQ(q.size(), 1u); | |
87 | BOOST_TEST(! q.closed()); | |
88 | } | |
89 | { | |
90 | // empty queue push lvalue/copyable succeeds | |
91 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
92 | boost::queue_back<int> q(sq); | |
93 | int i; | |
94 | q.push(i); | |
95 | BOOST_TEST(! q.empty()); | |
96 | BOOST_TEST(! q.full()); | |
97 | BOOST_TEST_EQ(q.size(), 1u); | |
98 | BOOST_TEST(! q.closed()); | |
99 | } | |
100 | ||
101 | ||
102 | #if 0 | |
103 | { | |
104 | // empty queue push rvalue/non_copyable succeeds | |
105 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
106 | boost::queue_back<non_copyable> q(sq); | |
107 | q.push(non_copyable(1)); | |
108 | BOOST_TEST(! q.empty()); | |
109 | BOOST_TEST(! q.full()); | |
110 | BOOST_TEST_EQ(q.size(), 1u); | |
111 | BOOST_TEST(! q.closed()); | |
112 | } | |
113 | #endif | |
b32b8144 | 114 | #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) |
7c673cae FG |
115 | { |
116 | // empty queue push rvalue/non_copyable succeeds | |
117 | boost::queue_adaptor<boost::sync_queue<non_copyable> > q; | |
118 | //boost::sync_queue<non_copyable> q; | |
119 | //boost::queue_back<non_copyable> q(sq); | |
120 | non_copyable nc(1); | |
121 | q.push(boost::move(nc)); | |
122 | BOOST_TEST(! q.empty()); | |
123 | BOOST_TEST(! q.full()); | |
124 | BOOST_TEST_EQ(q.size(), 1u); | |
125 | BOOST_TEST(! q.closed()); | |
126 | } | |
b32b8144 | 127 | #endif |
7c673cae FG |
128 | |
129 | { | |
130 | // empty queue push rvalue succeeds | |
131 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
132 | boost::queue_back<int> q(sq); | |
133 | q.push(1); | |
134 | q.push(2); | |
135 | BOOST_TEST(! q.empty()); | |
136 | BOOST_TEST(! q.full()); | |
137 | BOOST_TEST_EQ(q.size(), 2u); | |
138 | BOOST_TEST(! q.closed()); | |
139 | } | |
140 | { | |
141 | // empty queue push lvalue succeeds | |
142 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
143 | boost::queue_back<int> q(sq); | |
144 | int i; | |
145 | q.push(i); | |
146 | BOOST_TEST(! q.empty()); | |
147 | BOOST_TEST(! q.full()); | |
148 | BOOST_TEST_EQ(q.size(), 1u); | |
149 | BOOST_TEST(! q.closed()); | |
150 | } | |
151 | { | |
152 | // empty queue try_push rvalue/copyable succeeds | |
153 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
154 | boost::queue_back<int> q(sq); | |
155 | BOOST_TEST(boost::queue_op_status::success == q.try_push(1)); | |
156 | BOOST_TEST(! q.empty()); | |
157 | BOOST_TEST(! q.full()); | |
158 | BOOST_TEST_EQ(q.size(), 1u); | |
159 | BOOST_TEST(! q.closed()); | |
160 | } | |
161 | { | |
162 | // empty queue try_push rvalue/copyable succeeds | |
163 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
164 | boost::queue_back<int> q(sq); | |
165 | BOOST_TEST(boost::queue_op_status::success == q.try_push(1)); | |
166 | BOOST_TEST(! q.empty()); | |
167 | BOOST_TEST(! q.full()); | |
168 | BOOST_TEST_EQ(q.size(), 1u); | |
169 | BOOST_TEST(! q.closed()); | |
170 | } | |
171 | ||
172 | #if 0 | |
173 | { | |
174 | // empty queue try_push rvalue/non-copyable succeeds | |
175 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
176 | boost::queue_back<non_copyable> q(sq); | |
177 | non_copyable nc(1); | |
178 | BOOST_TEST(boost::queue_op_status::success == q.try_push(boost::move(nc))); | |
179 | BOOST_TEST(! q.empty()); | |
180 | BOOST_TEST(! q.full()); | |
181 | BOOST_TEST_EQ(q.size(), 1u); | |
182 | BOOST_TEST(! q.closed()); | |
183 | } | |
184 | #endif | |
185 | ||
186 | { | |
187 | // empty queue try_push lvalue succeeds | |
188 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
189 | boost::queue_back<int> q(sq); | |
190 | int i=0; | |
191 | BOOST_TEST(boost::queue_op_status::success == q.try_push(i)); | |
192 | BOOST_TEST(! q.empty()); | |
193 | BOOST_TEST(! q.full()); | |
194 | BOOST_TEST_EQ(q.size(), 1u); | |
195 | BOOST_TEST(! q.closed()); | |
196 | } | |
197 | { | |
198 | // empty queue try_push rvalue succeeds | |
199 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
200 | boost::queue_back<int> q(sq); | |
201 | BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(1)); | |
202 | BOOST_TEST(! q.empty()); | |
203 | BOOST_TEST(! q.full()); | |
204 | BOOST_TEST_EQ(q.size(), 1u); | |
205 | BOOST_TEST(! q.closed()); | |
206 | } | |
207 | ||
208 | ||
209 | #if 0 | |
210 | { | |
211 | // empty queue nonblocking_push rvalue/non-copyable succeeds | |
212 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
213 | boost::queue_back<non_copyable> q(sq); | |
214 | BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(non_copyable(1))); | |
215 | BOOST_TEST(! q.empty()); | |
216 | BOOST_TEST(! q.full()); | |
217 | BOOST_TEST_EQ(q.size(), 1u); | |
218 | BOOST_TEST(! q.closed()); | |
219 | } | |
220 | #endif | |
b32b8144 | 221 | #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) |
7c673cae FG |
222 | { |
223 | // empty queue nonblocking_push rvalue/non-copyable succeeds | |
224 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
225 | boost::queue_back<non_copyable> q(sq); | |
226 | non_copyable nc(1); | |
227 | BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(boost::move(nc))); | |
228 | BOOST_TEST(! q.empty()); | |
229 | BOOST_TEST(! q.full()); | |
230 | BOOST_TEST_EQ(q.size(), 1u); | |
231 | BOOST_TEST(! q.closed()); | |
232 | } | |
b32b8144 | 233 | #endif |
7c673cae FG |
234 | { |
235 | // 1-element queue pull succeed | |
236 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
237 | boost::queue_front<int> q(sq); | |
238 | sq.push(1); | |
239 | int i; | |
240 | q.pull(i); | |
241 | BOOST_TEST_EQ(i, 1); | |
242 | BOOST_TEST(q.empty()); | |
243 | BOOST_TEST(! q.full()); | |
244 | BOOST_TEST_EQ(q.size(), 0u); | |
245 | BOOST_TEST(! q.closed()); | |
246 | } | |
b32b8144 | 247 | #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) |
7c673cae FG |
248 | { |
249 | // 1-element queue pull succeed | |
250 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
251 | boost::queue_front<non_copyable> q(sq); | |
252 | non_copyable nc1(1); | |
253 | sq.push(boost::move(nc1)); | |
254 | non_copyable nc2(2); | |
255 | q.pull(nc2); | |
256 | BOOST_TEST_EQ(nc1, nc2); | |
257 | BOOST_TEST(q.empty()); | |
258 | BOOST_TEST(! q.full()); | |
259 | BOOST_TEST_EQ(q.size(), 0u); | |
260 | BOOST_TEST(! q.closed()); | |
261 | } | |
b32b8144 | 262 | #endif |
7c673cae FG |
263 | { |
264 | // 1-element queue pull succeed | |
265 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
266 | boost::queue_front<int> q(sq); | |
267 | sq.push(1); | |
268 | int i = q.pull(); | |
269 | BOOST_TEST_EQ(i, 1); | |
270 | BOOST_TEST(q.empty()); | |
271 | BOOST_TEST(! q.full()); | |
272 | BOOST_TEST_EQ(q.size(), 0u); | |
273 | BOOST_TEST(! q.closed()); | |
274 | } | |
b32b8144 | 275 | #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) |
7c673cae FG |
276 | { |
277 | // 1-element queue pull succeed | |
278 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
279 | boost::queue_front<non_copyable> q(sq); | |
280 | non_copyable nc1(1); | |
281 | sq.push(boost::move(nc1)); | |
282 | non_copyable nc = q.pull(); | |
283 | BOOST_TEST_EQ(nc, nc1); | |
284 | BOOST_TEST(q.empty()); | |
285 | BOOST_TEST(! q.full()); | |
286 | BOOST_TEST_EQ(q.size(), 0u); | |
287 | BOOST_TEST(! q.closed()); | |
288 | } | |
b32b8144 | 289 | #endif |
7c673cae FG |
290 | { |
291 | // 1-element queue try_pull succeed | |
292 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
293 | boost::queue_front<int> q(sq); | |
294 | sq.push(1); | |
295 | int i; | |
296 | BOOST_TEST(boost::queue_op_status::success == q.try_pull(i)); | |
297 | BOOST_TEST_EQ(i, 1); | |
298 | BOOST_TEST(q.empty()); | |
299 | BOOST_TEST(! q.full()); | |
300 | BOOST_TEST_EQ(q.size(), 0u); | |
301 | BOOST_TEST(! q.closed()); | |
302 | } | |
b32b8144 | 303 | #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) |
7c673cae FG |
304 | { |
305 | // 1-element queue try_pull succeed | |
306 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
307 | boost::queue_front<non_copyable> q(sq); | |
308 | non_copyable nc1(1); | |
309 | sq.push(boost::move(nc1)); | |
310 | non_copyable nc(2); | |
311 | BOOST_TEST(boost::queue_op_status::success == q.try_pull(nc)); | |
312 | BOOST_TEST_EQ(nc, nc1); | |
313 | BOOST_TEST(q.empty()); | |
314 | BOOST_TEST(! q.full()); | |
315 | BOOST_TEST_EQ(q.size(), 0u); | |
316 | BOOST_TEST(! q.closed()); | |
317 | } | |
b32b8144 | 318 | #endif |
7c673cae FG |
319 | { |
320 | // 1-element queue nonblocking_pull succeed | |
321 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
322 | boost::queue_front<int> q(sq); | |
323 | sq.push(1); | |
324 | int i; | |
325 | BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull(i)); | |
326 | BOOST_TEST_EQ(i, 1); | |
327 | BOOST_TEST(q.empty()); | |
328 | BOOST_TEST(! q.full()); | |
329 | BOOST_TEST_EQ(q.size(), 0u); | |
330 | BOOST_TEST(! q.closed()); | |
331 | } | |
b32b8144 | 332 | #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) |
7c673cae FG |
333 | { |
334 | // 1-element queue nonblocking_pull succeed | |
335 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
336 | boost::queue_front<non_copyable> q(sq); | |
337 | non_copyable nc1(1); | |
338 | sq.push(boost::move(nc1)); | |
339 | non_copyable nc(2); | |
340 | BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull(nc)); | |
341 | BOOST_TEST_EQ(nc, nc1); | |
342 | BOOST_TEST(q.empty()); | |
343 | BOOST_TEST(! q.full()); | |
344 | BOOST_TEST_EQ(q.size(), 0u); | |
345 | BOOST_TEST(! q.closed()); | |
346 | } | |
347 | { | |
348 | // 1-element queue wait_pull succeed | |
349 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
350 | boost::queue_front<non_copyable> q(sq); | |
351 | non_copyable nc1(1); | |
352 | sq.push(boost::move(nc1)); | |
353 | non_copyable nc(2); | |
354 | BOOST_TEST(boost::queue_op_status::success == q.wait_pull(nc)); | |
355 | BOOST_TEST_EQ(nc, nc1); | |
356 | BOOST_TEST(q.empty()); | |
357 | BOOST_TEST(! q.full()); | |
358 | BOOST_TEST_EQ(q.size(), 0u); | |
359 | BOOST_TEST(! q.closed()); | |
360 | } | |
b32b8144 | 361 | #endif |
7c673cae FG |
362 | { |
363 | // 1-element queue wait_pull succeed | |
364 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
365 | boost::queue_front<int> q(sq); | |
366 | sq.push(1); | |
367 | int i; | |
368 | BOOST_TEST(boost::queue_op_status::success == q.wait_pull(i)); | |
369 | BOOST_TEST_EQ(i, 1); | |
370 | BOOST_TEST(q.empty()); | |
371 | BOOST_TEST(! q.full()); | |
372 | BOOST_TEST_EQ(q.size(), 0u); | |
373 | BOOST_TEST(! q.closed()); | |
374 | } | |
b32b8144 | 375 | #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) |
7c673cae FG |
376 | { |
377 | // 1-element queue wait_pull succeed | |
378 | boost::queue_adaptor<boost::sync_queue<non_copyable> > sq; | |
379 | boost::queue_front<non_copyable> q(sq); | |
380 | non_copyable nc1(1); | |
381 | sq.push(boost::move(nc1)); | |
382 | non_copyable nc(2); | |
383 | BOOST_TEST(boost::queue_op_status::success == q.wait_pull(nc)); | |
384 | BOOST_TEST_EQ(nc, nc1); | |
385 | BOOST_TEST(q.empty()); | |
386 | BOOST_TEST(! q.full()); | |
387 | BOOST_TEST_EQ(q.size(), 0u); | |
388 | BOOST_TEST(! q.closed()); | |
389 | } | |
b32b8144 | 390 | #endif |
7c673cae FG |
391 | { |
392 | // closed invariants | |
393 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
394 | boost::queue_back<int> q(sq); | |
395 | q.close(); | |
396 | BOOST_TEST(q.empty()); | |
397 | BOOST_TEST(! q.full()); | |
398 | BOOST_TEST_EQ(q.size(), 0u); | |
399 | BOOST_TEST(q.closed()); | |
400 | } | |
401 | { | |
402 | // closed invariants | |
403 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
404 | boost::queue_front<int> q(sq); | |
405 | q.close(); | |
406 | BOOST_TEST(q.empty()); | |
407 | BOOST_TEST(! q.full()); | |
408 | BOOST_TEST_EQ(q.size(), 0u); | |
409 | BOOST_TEST(q.closed()); | |
410 | } | |
411 | { | |
412 | // closed queue push fails | |
413 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
414 | boost::queue_back<int> q(sq); | |
415 | q.close(); | |
416 | try { | |
417 | q.push(1); | |
418 | BOOST_TEST(false); | |
419 | } catch (...) { | |
420 | BOOST_TEST(q.empty()); | |
421 | BOOST_TEST(! q.full()); | |
422 | BOOST_TEST_EQ(q.size(), 0u); | |
423 | BOOST_TEST(q.closed()); | |
424 | } | |
425 | } | |
426 | { | |
427 | // 1-element closed queue pull succeed | |
428 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
429 | boost::queue_front<int> q(sq); | |
430 | sq.push(1); | |
431 | q.close(); | |
432 | int i; | |
433 | q.pull(i); | |
434 | BOOST_TEST_EQ(i, 1); | |
435 | BOOST_TEST(q.empty()); | |
436 | BOOST_TEST(! q.full()); | |
437 | BOOST_TEST_EQ(q.size(), 0u); | |
438 | BOOST_TEST(q.closed()); | |
439 | } | |
440 | { | |
441 | // 1-element closed queue wait_pull succeed | |
442 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
443 | boost::queue_front<int> q(sq); | |
444 | sq.push(1); | |
445 | q.close(); | |
446 | int i; | |
447 | BOOST_TEST(boost::queue_op_status::success == q.wait_pull(i)); | |
448 | BOOST_TEST_EQ(i, 1); | |
449 | BOOST_TEST(q.empty()); | |
450 | BOOST_TEST(! q.full()); | |
451 | BOOST_TEST_EQ(q.size(), 0u); | |
452 | BOOST_TEST(q.closed()); | |
453 | } | |
454 | { | |
455 | // closed empty queue wait_pull fails | |
456 | boost::queue_adaptor<boost::sync_queue<int> > sq; | |
457 | boost::queue_front<int> q(sq); | |
458 | q.close(); | |
459 | BOOST_TEST(q.empty()); | |
460 | BOOST_TEST(q.closed()); | |
461 | int i; | |
462 | BOOST_TEST(boost::queue_op_status::closed == q.wait_pull(i)); | |
463 | BOOST_TEST(q.empty()); | |
464 | BOOST_TEST(q.closed()); | |
465 | } | |
466 | return boost::report_errors(); | |
467 | } | |
468 |