1 // Test of the base circular buffer container.
2
3 // Copyright (c) 2003-2008 Jan Gaspar
4 // Copyright (c) 2013 Antony Polukhin
5
6 // Use, modification, and distribution is subject to the Boost Software
7 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt)
9
10 #include "test.hpp"
11
12 #define CB_CONTAINER circular_buffer
13
14 #include "common.ipp"
15
iterator_constructor_and_assign_test()16 void iterator_constructor_and_assign_test() {
17
18 circular_buffer<MyInteger> cb(4, 3);
19 circular_buffer<MyInteger>::iterator it = cb.begin();
20 circular_buffer<MyInteger>::const_iterator cit2 = cb.cbegin();
21 circular_buffer<MyInteger>::iterator itCopy;
22 itCopy = it;
23 it = it;
24 circular_buffer<MyInteger>::const_iterator cit;
25 cit = it;
26 circular_buffer<MyInteger>::const_iterator end1 = cb.end();
27 circular_buffer<MyInteger>::const_iterator end2 = end1;
28 circular_buffer<MyInteger>::const_iterator end3 = cb.cend();
29
30 BOOST_TEST(itCopy == it);
31 BOOST_TEST(cit == it);
32 BOOST_TEST(end1 == end2);
33 BOOST_TEST(it != end1);
34 BOOST_TEST(cit != end2);
35 BOOST_TEST(cit2 == it);
36 BOOST_TEST(end3 == end1);
37 }
38
iterator_reference_test()39 void iterator_reference_test() {
40
41 circular_buffer<Dummy> cb(3, Dummy());
42 circular_buffer<Dummy>::iterator it = cb.begin();
43 circular_buffer<Dummy>::const_iterator cit = cb.begin() + 1;
44
45 BOOST_TEST((*it).m_n == Dummy::eVar);
46 BOOST_TEST((*it).fnc() == Dummy::eFnc);
47 BOOST_TEST((*cit).const_fnc() == Dummy::eConst);
48 BOOST_TEST((*it).virtual_fnc() == Dummy::eVirtual);
49 BOOST_TEST(it->m_n == Dummy::eVar);
50 BOOST_TEST(it->fnc() == Dummy::eFnc);
51 BOOST_TEST(cit->const_fnc() == Dummy::eConst);
52 BOOST_TEST(it->virtual_fnc() == Dummy::eVirtual);
53 }
54
iterator_difference_test()55 void iterator_difference_test() {
56
57 circular_buffer<MyInteger> cb(5, 1);
58 cb.push_back(2);
59 circular_buffer<MyInteger>::iterator it1 = cb.begin() + 2;
60 circular_buffer<MyInteger>::iterator it2 = cb.begin() + 3;
61 circular_buffer<MyInteger>::const_iterator begin = cb.begin();
62 circular_buffer<MyInteger>::iterator end = cb.end();
63
64 BOOST_TEST(begin - begin == 0);
65 BOOST_TEST(end - cb.begin() == 5);
66 BOOST_TEST(end - end == 0);
67 BOOST_TEST(begin - cb.end() == -5);
68 BOOST_TEST(it1 - cb.begin() == 2);
69 BOOST_TEST(it1 - begin == 2);
70 BOOST_TEST(end - it1 == 3);
71 BOOST_TEST(it2 - it1 == 1);
72 BOOST_TEST(it1 - it2 == -1);
73 BOOST_TEST(it2 - it2 == 0);
74 }
75
iterator_increment_test()76 void iterator_increment_test() {
77
78 circular_buffer<MyInteger> cb(10, 1);
79 cb.push_back(2);
80 circular_buffer<MyInteger>::iterator it1 = cb.begin();
81 circular_buffer<MyInteger>::iterator it2 = cb.begin() + 5;
82 circular_buffer<MyInteger>::iterator it3 = cb.begin() + 9;
83 it1++;
84 it2++;
85 ++it3;
86
87 BOOST_TEST(it1 == cb.begin() + 1);
88 BOOST_TEST(it2 == cb.begin() + 6);
89 BOOST_TEST(it3 == cb.end());
90 }
91
iterator_decrement_test()92 void iterator_decrement_test() {
93
94 circular_buffer<MyInteger> cb(10, 1);
95 cb.push_back(2);
96 circular_buffer<MyInteger>::iterator it1= cb.end();
97 circular_buffer<MyInteger>::iterator it2= cb.end() - 5;
98 circular_buffer<MyInteger>::iterator it3= cb.end() - 9;
99 --it1;
100 it2--;
101 --it3;
102
103 BOOST_TEST(it1 == cb.end() - 1);
104 BOOST_TEST(it2 == cb.end() - 6);
105 BOOST_TEST(it3 == cb.begin());
106 }
107
iterator_addition_test()108 void iterator_addition_test() {
109
110 circular_buffer<MyInteger> cb(10, 1);
111 cb.push_back(2);
112 cb.push_back(2);
113 circular_buffer<MyInteger>::iterator it1 = cb.begin() + 2;
114 circular_buffer<MyInteger>::iterator it2 = cb.end();
115 circular_buffer<MyInteger>::iterator it3 = cb.begin() + 5;
116 circular_buffer<MyInteger>::iterator it4 = cb.begin() + 9;
117 it1 += 3;
118 it2 += 0;
119 it3 += 5;
120 it4 += -2;
121
122 BOOST_TEST(it1 == 5 + cb.begin());
123 BOOST_TEST(it2 == cb.end());
124 BOOST_TEST(it3 == cb.end());
125 BOOST_TEST(it4 + 3 == cb.end());
126 BOOST_TEST((-3) + it4 == cb.begin() + 4);
127 BOOST_TEST(cb.begin() + 0 == cb.begin());
128 }
129
iterator_subtraction_test()130 void iterator_subtraction_test() {
131
132 circular_buffer<MyInteger> cb(10, 1);
133 cb.push_back(2);
134 cb.push_back(2);
135 cb.push_back(2);
136 circular_buffer<MyInteger>::iterator it1 = cb.begin();
137 circular_buffer<MyInteger>::iterator it2 = cb.end();
138 circular_buffer<MyInteger>::iterator it3 = cb.end() - 5;
139 circular_buffer<MyInteger>::iterator it4 = cb.begin() + 7;
140 it1 -= -2;
141 it2 -= 0;
142 it3 -= 5;
143
144 BOOST_TEST(it1 == cb.begin() + 2);
145 BOOST_TEST(it2 == cb.end());
146 BOOST_TEST(it3 == cb.begin());
147 BOOST_TEST(it4 - 7 == cb.begin());
148 BOOST_TEST(it4 - (-3) == cb.end());
149 BOOST_TEST(cb.begin() - 0 == cb.begin());
150 }
151
iterator_element_access_test()152 void iterator_element_access_test() {
153
154 circular_buffer<MyInteger> cb(10);
155 cb.push_back(1);
156 cb.push_back(2);
157 cb.push_back(3);
158 cb.push_back(4);
159 cb.push_back(5);
160 cb.push_back(6);
161 circular_buffer<MyInteger>::iterator it = cb.begin() + 1;
162
163 BOOST_TEST(it[0] == 2);
164 BOOST_TEST(it[-1] == 1);
165 BOOST_TEST(it[2] == 4);
166 }
167
iterator_comparison_test()168 void iterator_comparison_test() {
169
170 circular_buffer<MyInteger> cb(5, 1);
171 cb.push_back(2);
172 circular_buffer<MyInteger>::iterator it = cb.begin() + 2;
173 circular_buffer<MyInteger>::const_iterator begin = cb.begin();
174 circular_buffer<MyInteger>::iterator end = cb.end();
175
176 BOOST_TEST(begin == begin);
177 BOOST_TEST(end > cb.begin());
178 BOOST_TEST(begin < end);
179 BOOST_TEST(end > begin);
180 BOOST_TEST(end == end);
181 BOOST_TEST(begin < cb.end());
182 BOOST_TEST(!(begin + 1 > cb.end()));
183 BOOST_TEST(it > cb.begin());
184 BOOST_TEST(end > it);
185 BOOST_TEST(begin >= begin);
186 BOOST_TEST(end >= cb.begin());
187 BOOST_TEST(end <= end);
188 BOOST_TEST(begin <= cb.end());
189 BOOST_TEST(it >= cb.begin());
190 BOOST_TEST(end >= it);
191 BOOST_TEST(!(begin + 4 < begin + 4));
192 BOOST_TEST(begin + 4 < begin + 5);
193 BOOST_TEST(!(begin + 5 < begin + 4));
194 BOOST_TEST(it < end - 1);
195 BOOST_TEST(!(end - 1 < it));
196 }
197
iterator_invalidation_test()198 void iterator_invalidation_test() {
199
200 #if BOOST_CB_ENABLE_DEBUG
201
202 circular_buffer<MyInteger>::iterator it1;
203 circular_buffer<MyInteger>::const_iterator it2;
204 circular_buffer<MyInteger>::iterator it3;
205 circular_buffer<MyInteger>::const_iterator it4;
206 circular_buffer<MyInteger>::const_iterator it5;
207 circular_buffer<MyInteger>::const_iterator it6;
208
209 BOOST_TEST(it1.is_valid(0));
210 BOOST_TEST(it2.is_valid(0));
211 BOOST_TEST(it3.is_valid(0));
212 BOOST_TEST(it4.is_valid(0));
213 BOOST_TEST(it5.is_valid(0));
214 BOOST_TEST(it6.is_valid(0));
215
216 {
217 circular_buffer<MyInteger> cb(5, 0);
218 const circular_buffer<MyInteger> ccb(5, 0);
219
220 it1 = cb.begin();
221 it2 = ccb.begin();
222 it3 = cb.end();
223 it4 = it1;
224 it5 = it2;
225 it6 = it1;
226
227 BOOST_TEST(it1.is_valid(&cb));
228 BOOST_TEST(it2.is_valid(&ccb));
229 BOOST_TEST(it3.is_valid(&cb));
230 BOOST_TEST(it4.is_valid(&cb));
231 BOOST_TEST(it5.is_valid(&ccb));
232 BOOST_TEST(it6.is_valid(&cb));
233 }
234
235 BOOST_TEST(it1.is_valid(0));
236 BOOST_TEST(it2.is_valid(0));
237 BOOST_TEST(it3.is_valid(0));
238 BOOST_TEST(it4.is_valid(0));
239 BOOST_TEST(it5.is_valid(0));
240 BOOST_TEST(it6.is_valid(0));
241
242 circular_buffer<MyInteger> cb(10, 0);
243 it1 = cb.end();
244 cb.clear();
245 BOOST_TEST(it1.is_valid(&cb));
246 cb.push_back(1);
247 cb.push_back(2);
248 cb.push_back(3);
249 int i = 0;
250 for (it2 = cb.begin(); it2 != it1; it2++, i++);
251 BOOST_TEST(i == 3);
252
253 circular_buffer<MyInteger> cb1(10, 0);
254 circular_buffer<MyInteger> cb2(20, 0);
255 it1 = cb1.end();
256 it2 = cb2.begin();
257 BOOST_TEST(it1.is_valid(&cb1));
258 BOOST_TEST(it2.is_valid(&cb2));
259
260 cb1.swap(cb2);
261 BOOST_TEST(!it1.is_valid(&cb1));
262 BOOST_TEST(!it2.is_valid(&cb2));
263
264 it1 = cb1.begin() + 3;
265 it2 = cb1.begin();
266 cb1.push_back(1);
267 BOOST_TEST(it1.is_valid(&cb1));
268 BOOST_TEST(!it2.is_valid(&cb1));
269 BOOST_TEST(*it2.m_it == 1);
270
271 circular_buffer<MyInteger> cb3(5);
272 cb3.push_back(1);
273 cb3.push_back(2);
274 cb3.push_back(3);
275 cb3.push_back(4);
276 cb3.push_back(5);
277 it1 = cb3.begin() + 2;
278 it2 = cb3.begin();
279 cb3.insert(cb3.begin() + 3, 6);
280 BOOST_TEST(it1.is_valid(&cb3));
281 BOOST_TEST(!it2.is_valid(&cb3));
282 BOOST_TEST(*it2.m_it == 5);
283
284 it1 = cb3.begin() + 3;
285 it2 = cb3.end() - 1;
286 cb3.push_front(7);
287 BOOST_TEST(it1.is_valid(&cb3));
288 BOOST_TEST(!it2.is_valid(&cb3));
289 BOOST_TEST(*it2.m_it == 7);
290
291 circular_buffer<MyInteger> cb4(5);
292 cb4.push_back(1);
293 cb4.push_back(2);
294 cb4.push_back(3);
295 cb4.push_back(4);
296 cb4.push_back(5);
297 it1 = cb4.begin() + 3;
298 it2 = cb4.begin();
299 cb4.rinsert(cb4.begin() + 2, 6);
300 BOOST_TEST(it1.is_valid(&cb4));
301 BOOST_TEST(!it2.is_valid(&cb4));
302 BOOST_TEST(*it2.m_it == 2);
303
304 it1 = cb1.begin() + 5;
305 it2 = cb1.end() - 1;
306 cb1.pop_back();
307 BOOST_TEST(it1.is_valid(&cb1));
308 BOOST_TEST(!it2.is_valid(&cb1));
309
310 it1 = cb1.begin() + 5;
311 it2 = cb1.begin();
312 cb1.pop_front();
313 BOOST_TEST(it1.is_valid(&cb1));
314 BOOST_TEST(!it2.is_valid(&cb1));
315
316 circular_buffer<MyInteger> cb5(20, 0);
317 it1 = cb5.begin() + 5;
318 it2 = it3 = cb5.begin() + 15;
319 cb5.erase(cb5.begin() + 10);
320 BOOST_TEST(it1.is_valid(&cb5));
321 BOOST_TEST(!it2.is_valid(&cb5));
322 BOOST_TEST(!it3.is_valid(&cb5));
323
324 it1 = cb5.begin() + 1;
325 it2 = it3 = cb5.begin() + 8;
326 cb5.erase(cb5.begin() + 3, cb5.begin() + 7);
327 BOOST_TEST(it1.is_valid(&cb5));
328 BOOST_TEST(!it2.is_valid(&cb5));
329 BOOST_TEST(!it3.is_valid(&cb5));
330
331 circular_buffer<MyInteger> cb6(20, 0);
332 it4 = it1 = cb6.begin() + 5;
333 it2 = cb6.begin() + 15;
334 cb6.rerase(cb6.begin() + 10);
335 BOOST_TEST(!it1.is_valid(&cb6));
336 BOOST_TEST(!it4.is_valid(&cb6));
337 BOOST_TEST(it2.is_valid(&cb6));
338
339 it4 = it1 = cb6.begin() + 1;
340 it2 = cb6.begin() + 8;
341 cb6.rerase(cb6.begin() + 3, cb6.begin() + 7);
342 BOOST_TEST(!it1.is_valid(&cb6));
343 BOOST_TEST(!it4.is_valid(&cb6));
344 BOOST_TEST(it2.is_valid(&cb6));
345
346 circular_buffer<MyInteger> cb7(10, 1);
347 cb7.push_back(2);
348 cb7.push_back(3);
349 cb7.push_back(4);
350 it1 = cb7.end();
351 it2 = cb7.begin();
352 it3 = cb7.begin() + 6;
353 cb7.linearize();
354 BOOST_TEST(it1.is_valid(&cb7));
355 BOOST_TEST(!it2.is_valid(&cb7));
356 BOOST_TEST(!it3.is_valid(&cb7));
357 it1 = cb7.end();
358 it2 = cb7.begin();
359 it3 = cb7.begin() + 6;
360 cb7.linearize();
361 BOOST_TEST(it1.is_valid(&cb7));
362 BOOST_TEST(it2.is_valid(&cb7));
363 BOOST_TEST(it3.is_valid(&cb7));
364
365 cb7.push_back(5);
366 cb7.push_back(6);
367 it1 = cb7.end();
368 it2 = cb7.begin();
369 it3 = cb7.begin() + 6;
370 cb7.set_capacity(10);
371 BOOST_TEST(it1.is_valid(&cb7));
372 BOOST_TEST(it2.is_valid(&cb7));
373 BOOST_TEST(it3.is_valid(&cb7));
374 cb7.set_capacity(20);
375 BOOST_TEST(it1.is_valid(&cb7));
376 BOOST_TEST(!it2.is_valid(&cb7));
377 BOOST_TEST(!it3.is_valid(&cb7));
378 cb7.push_back(7);
379 it1 = cb7.end();
380 it2 = cb7.begin();
381 it3 = cb7.begin() + 6;
382 cb7.set_capacity(10);
383 BOOST_TEST(it1.is_valid(&cb7));
384 BOOST_TEST(!it2.is_valid(&cb7));
385 BOOST_TEST(!it3.is_valid(&cb7));
386
387 cb7.push_back(8);
388 cb7.push_back(9);
389 it1 = cb7.end();
390 it2 = cb7.begin();
391 it3 = cb7.begin() + 6;
392 cb7.rset_capacity(10);
393 BOOST_TEST(it1.is_valid(&cb7));
394 BOOST_TEST(it2.is_valid(&cb7));
395 BOOST_TEST(it3.is_valid(&cb7));
396 cb7.rset_capacity(20);
397 BOOST_TEST(it1.is_valid(&cb7));
398 BOOST_TEST(!it2.is_valid(&cb7));
399 BOOST_TEST(!it3.is_valid(&cb7));
400 cb7.push_back(10);
401 it1 = cb7.end();
402 it2 = cb7.begin();
403 it3 = cb7.begin() + 6;
404 cb7.rset_capacity(10);
405 BOOST_TEST(it1.is_valid(&cb7));
406 BOOST_TEST(!it2.is_valid(&cb7));
407 BOOST_TEST(!it3.is_valid(&cb7));
408
409 circular_buffer<MyInteger> cb8(10, 1);
410 cb8.push_back(2);
411 cb8.push_back(3);
412 it1 = cb8.end();
413 it2 = cb8.begin();
414 it3 = cb8.begin() + 6;
415 cb8.resize(10);
416 BOOST_TEST(it1.is_valid(&cb8));
417 BOOST_TEST(it2.is_valid(&cb8));
418 BOOST_TEST(it3.is_valid(&cb8));
419 cb8.resize(20);
420 BOOST_TEST(it1.is_valid(&cb8));
421 BOOST_TEST(!it2.is_valid(&cb8));
422 BOOST_TEST(!it3.is_valid(&cb8));
423 cb8.push_back(4);
424 it1 = cb8.end();
425 it2 = cb8.begin();
426 it3 = cb8.begin() + 6;
427 it4 = cb8.begin() + 12;
428 cb8.resize(10);
429 BOOST_TEST(it1.is_valid(&cb8));
430 BOOST_TEST(it2.is_valid(&cb8));
431 BOOST_TEST(it3.is_valid(&cb8));
432 BOOST_TEST(!it4.is_valid(&cb8));
433
434 cb8.set_capacity(10);
435 cb8.push_back(5);
436 cb8.push_back(6);
437 it1 = cb8.end();
438 it2 = cb8.begin();
439 it3 = cb8.begin() + 6;
440 cb8.rresize(10);
441 BOOST_TEST(it1.is_valid(&cb8));
442 BOOST_TEST(it2.is_valid(&cb8));
443 BOOST_TEST(it3.is_valid(&cb8));
444 cb8.rresize(20);
445 BOOST_TEST(it1.is_valid(&cb8));
446 BOOST_TEST(!it2.is_valid(&cb8));
447 BOOST_TEST(!it3.is_valid(&cb8));
448 cb8.push_back(7);
449 it1 = cb8.end();
450 it2 = cb8.begin();
451 it3 = cb8.begin() + 6;
452 it4 = cb8.begin() + 12;
453 cb8.rresize(10);
454 BOOST_TEST(it1.is_valid(&cb8));
455 BOOST_TEST(!it2.is_valid(&cb8));
456 BOOST_TEST(!it3.is_valid(&cb8));
457 BOOST_TEST(it4.is_valid(&cb8));
458
459 circular_buffer<MyInteger> cb9(15, 1);
460 it1 = cb9.end();
461 it2 = cb9.begin();
462 it3 = cb9.begin() + 6;
463 it4 = cb9.begin() + 12;
464 cb9 = cb8;
465 BOOST_TEST(it1.is_valid(&cb9));
466 BOOST_TEST(!it2.is_valid(&cb9));
467 BOOST_TEST(!it3.is_valid(&cb9));
468 BOOST_TEST(!it4.is_valid(&cb9));
469
470 circular_buffer<MyInteger> cb10(10, 1);
471 it1 = cb10.end();
472 it2 = cb10.begin();
473 it3 = cb10.begin() + 3;
474 it4 = cb10.begin() + 7;
475 cb10.assign(5, 2);
476 BOOST_TEST(it1.is_valid(&cb10));
477 BOOST_TEST(!it2.is_valid(&cb10));
478 BOOST_TEST(!it3.is_valid(&cb10));
479 BOOST_TEST(!it4.is_valid(&cb10));
480
481 circular_buffer<MyInteger> cb11(10, 1);
482 it1 = cb11.end();
483 it2 = cb11.begin();
484 it3 = cb11.begin() + 3;
485 it4 = cb11.begin() + 7;
486 cb11.assign(15, 5, 2);
487 BOOST_TEST(it1.is_valid(&cb11));
488 BOOST_TEST(!it2.is_valid(&cb11));
489 BOOST_TEST(!it3.is_valid(&cb11));
490 BOOST_TEST(!it4.is_valid(&cb11));
491
492 circular_buffer<MyInteger> cb12(10, 1);
493 it1 = cb12.end();
494 it2 = cb12.begin();
495 it3 = cb12.begin() + 3;
496 it4 = cb12.begin() + 7;
497 cb12.assign(cb11.begin(), cb11.end());
498 BOOST_TEST(it1.is_valid(&cb12));
499 BOOST_TEST(!it2.is_valid(&cb12));
500 BOOST_TEST(!it3.is_valid(&cb12));
501 BOOST_TEST(!it4.is_valid(&cb12));
502
503 circular_buffer<MyInteger> cb13(10, 1);
504 it1 = cb13.end();
505 it2 = cb13.begin();
506 it3 = cb13.begin() + 3;
507 it4 = cb13.begin() + 7;
508 cb13.assign(15, cb11.begin(), cb11.end());
509 BOOST_TEST(it1.is_valid(&cb13));
510 BOOST_TEST(!it2.is_valid(&cb13));
511 BOOST_TEST(!it3.is_valid(&cb13));
512 BOOST_TEST(!it4.is_valid(&cb13));
513
514 circular_buffer<MyInteger> cb14(10);
515 cb14.push_back(1);
516 cb14.push_back(2);
517 cb14.push_back(3);
518 cb14.push_back(4);
519 cb14.push_back(5);
520 cb14.push_back(6);
521 cb14.push_back(7);
522 it1 = cb14.end();
523 it2 = cb14.begin() + 2;
524 it3 = cb14.begin() + 1;
525 it4 = cb14.begin() + 5;
526 cb14.rotate(it2);
527 BOOST_TEST(it1.is_valid(&cb14));
528 BOOST_TEST(it2.is_valid(&cb14));
529 BOOST_TEST(!it3.is_valid(&cb14));
530 BOOST_TEST(it4.is_valid(&cb14));
531
532 circular_buffer<MyInteger> cb15(7);
533 cb15.push_back(1);
534 cb15.push_back(2);
535 cb15.push_back(3);
536 cb15.push_back(4);
537 cb15.push_back(5);
538 cb15.push_back(6);
539 cb15.push_back(7);
540 cb15.push_back(8);
541 cb15.push_back(9);
542 it1 = cb15.end();
543 it2 = cb15.begin() + 2;
544 it3 = cb15.begin() + 1;
545 it4 = cb15.begin() + 5;
546 cb15.rotate(it3);
547 BOOST_TEST(it1.is_valid(&cb15));
548 BOOST_TEST(it2.is_valid(&cb15));
549 BOOST_TEST(it3.is_valid(&cb15));
550 BOOST_TEST(it4.is_valid(&cb15));
551
552 circular_buffer<MyInteger> cb16(10);
553 cb16.push_back(1);
554 cb16.push_back(2);
555 cb16.push_back(3);
556 cb16.push_back(4);
557 cb16.push_back(5);
558 cb16.push_back(6);
559 cb16.push_back(7);
560 it1 = cb16.end();
561 it2 = cb16.begin() + 6;
562 it3 = cb16.begin();
563 it4 = cb16.begin() + 5;
564 cb16.rotate(it4);
565 BOOST_TEST(it1.is_valid(&cb16));
566 BOOST_TEST(!it2.is_valid(&cb16));
567 BOOST_TEST(it3.is_valid(&cb16));
568 BOOST_TEST(!it4.is_valid(&cb16));
569
570 #endif // #if BOOST_CB_ENABLE_DEBUG
571 }
572
573 // basic exception safety test (it is useful to use any memory-leak detection tool)
exception_safety_test()574 void exception_safety_test() {
575
576 #if !defined(BOOST_NO_EXCEPTIONS)
577
578 circular_buffer<MyInteger> cb1(3, 5);
579 MyInteger::set_exception_trigger(3);
580 BOOST_TEST_THROWS(cb1.set_capacity(5), std::exception);
581 BOOST_TEST(cb1.capacity() == 3);
582 MyInteger::set_exception_trigger(3);
583 BOOST_TEST_THROWS(cb1.rset_capacity(5), std::exception);
584 BOOST_TEST(cb1.capacity() == 3);
585 generic_test(cb1);
586
587 MyInteger::set_exception_trigger(3);
588 BOOST_TEST_THROWS(circular_buffer<MyInteger> cb2(5, 10), std::exception);
589
590 circular_buffer<MyInteger> cb3(5, 10);
591 MyInteger::set_exception_trigger(3);
592 BOOST_TEST_THROWS(circular_buffer<MyInteger> cb4(cb3), std::exception);
593
594 vector<MyInteger> v(5, MyInteger(10));
595 MyInteger::set_exception_trigger(3);
596 BOOST_TEST_THROWS(circular_buffer<MyInteger> cb5(8, v.begin(), v.end()), std::exception);
597
598 circular_buffer<MyInteger> cb6(5, 10);
599 circular_buffer<MyInteger> cb7(8, 3);
600 MyInteger::set_exception_trigger(3);
601 BOOST_TEST_THROWS(cb7 = cb6, std::exception);
602 BOOST_TEST(cb7.size() == 8);
603 BOOST_TEST(cb7.capacity() == 8);
604 BOOST_TEST(cb7[0] == 3);
605 BOOST_TEST(cb7[7] == 3);
606 generic_test(cb7);
607
608 circular_buffer<MyInteger> cb8(5, 10);
609 MyInteger::set_exception_trigger(2);
610 BOOST_TEST_THROWS(cb8.push_front(1), std::exception);
611
612 circular_buffer<MyInteger> cb9(5);
613 cb9.push_back(1);
614 cb9.push_back(2);
615 cb9.push_back(3);
616 MyInteger::set_exception_trigger(3);
617 BOOST_TEST_THROWS(cb9.insert(cb9.begin() + 1, 4), std::exception);
618
619 circular_buffer<MyInteger> cb10(5);
620 cb10.push_back(1);
621 cb10.push_back(2);
622 cb10.push_back(3);
623 MyInteger::set_exception_trigger(3);
624 BOOST_TEST_THROWS(cb10.rinsert(cb10.begin() + 1, 4), std::exception);
625
626 circular_buffer<MyInteger> cb11(5);
627 cb11.push_back(1);
628 cb11.push_back(2);
629 MyInteger::set_exception_trigger(2);
630 BOOST_TEST_THROWS(cb11.rinsert(cb11.begin(), 1), std::exception);
631
632 circular_buffer<MyInteger> cb12(5, 1);
633 MyInteger::set_exception_trigger(3);
634 BOOST_TEST_THROWS(cb12.assign(4, 2), std::exception);
635
636 circular_buffer<MyInteger> cb13(5, 1);
637 MyInteger::set_exception_trigger(3);
638 BOOST_TEST_THROWS(cb13.assign(6, 2), std::exception);
639
640 circular_buffer<MyInteger> cb14(5);
641 cb14.push_back(1);
642 cb14.push_back(2);
643 MyInteger::set_exception_trigger(3);
644 BOOST_TEST_THROWS(cb14.insert(cb14.begin(), 10, 3), std::exception);
645
646 circular_buffer<MyInteger> cb15(5);
647 cb15.push_back(1);
648 cb15.push_back(2);
649 MyInteger::set_exception_trigger(3);
650 BOOST_TEST_THROWS(cb15.insert(cb15.end(), 10, 3), std::exception);
651
652 circular_buffer<MyInteger> cb16(5);
653 cb16.push_back(1);
654 cb16.push_back(2);
655 MyInteger::set_exception_trigger(3);
656 BOOST_TEST_THROWS(cb16.rinsert(cb16.begin(), 10, 3), std::exception);
657
658 circular_buffer<MyInteger> cb17(5);
659 cb17.push_back(1);
660 cb17.push_back(2);
661 MyInteger::set_exception_trigger(3);
662 BOOST_TEST_THROWS(cb17.rinsert(cb17.end(), 10, 3), std::exception);
663
664 circular_buffer<MyInteger> cb18(5, 0);
665 cb18.push_back(1);
666 cb18.push_back(2);
667 cb18.pop_front();
668 MyInteger::set_exception_trigger(4);
669 BOOST_TEST_THROWS(cb18.linearize(), std::exception);
670
671 circular_buffer<MyInteger> cb19(5, 0);
672 cb19.push_back(1);
673 cb19.push_back(2);
674 MyInteger::set_exception_trigger(5);
675 BOOST_TEST_THROWS(cb19.linearize(), std::exception);
676
677 circular_buffer<MyInteger> cb20(5, 0);
678 cb20.push_back(1);
679 cb20.push_back(2);
680 MyInteger::set_exception_trigger(6);
681 BOOST_TEST_THROWS(cb20.linearize(), std::exception);
682
683 circular_buffer<MyInteger> cb21(5);
684 cb21.push_back(1);
685 cb21.push_back(2);
686 cb21.push_back(3);
687 MyInteger::set_exception_trigger(2);
688 BOOST_TEST_THROWS(cb21.insert(cb21.begin() + 1, 4), std::exception);
689
690 circular_buffer<MyInteger> cb22(5);
691 cb22.push_back(1);
692 cb22.push_back(2);
693 cb22.push_back(3);
694 MyInteger::set_exception_trigger(2);
695 BOOST_TEST_THROWS(cb22.insert(cb22.end(), 4), std::exception);
696
697 circular_buffer<MyInteger> cb23(5, 0);
698 MyInteger::set_exception_trigger(2);
699 BOOST_TEST_THROWS(cb23.insert(cb23.begin() + 1, 4), std::exception);
700
701 circular_buffer<MyInteger> cb24(5);
702 cb24.push_back(1);
703 cb24.push_back(2);
704 cb24.push_back(3);
705 MyInteger::set_exception_trigger(2);
706 BOOST_TEST_THROWS(cb24.rinsert(cb24.begin() + 1, 4), std::exception);
707
708 circular_buffer<MyInteger> cb25(5, 0);
709 MyInteger::set_exception_trigger(2);
710 BOOST_TEST_THROWS(cb25.rinsert(cb25.begin() + 3, 4), std::exception);
711
712 circular_buffer<MyInteger> cb26(5);
713 cb26.push_back(1);
714 cb26.push_back(2);
715 MyInteger::set_exception_trigger(5);
716 BOOST_TEST_THROWS(cb26.insert(cb26.begin(), 10, 3), std::exception);
717
718 circular_buffer<MyInteger> cb27(5);
719 cb27.push_back(1);
720 cb27.push_back(2);
721 MyInteger::set_exception_trigger(5);
722 BOOST_TEST_THROWS(cb27.insert(cb27.end(), 10, 3), std::exception);
723
724 circular_buffer<MyInteger> cb28(5);
725 cb28.push_back(1);
726 cb28.push_back(2);
727 MyInteger::set_exception_trigger(5);
728 BOOST_TEST_THROWS(cb28.rinsert(cb28.begin(), 10, 3), std::exception);
729
730 circular_buffer<MyInteger> cb29(5);
731 cb29.push_back(1);
732 cb29.push_back(2);
733 MyInteger::set_exception_trigger(5);
734 BOOST_TEST_THROWS(cb29.rinsert(cb29.end(), 10, 3), std::exception);
735
736 circular_buffer<MyInteger> cb30(10);
737 cb30.push_back(1);
738 cb30.push_back(2);
739 cb30.push_back(3);
740 MyInteger::set_exception_trigger(2);
741 BOOST_TEST_THROWS(cb30.rinsert(cb30.begin(), 10, 3), std::exception);
742
743 #endif // #if !defined(BOOST_NO_EXCEPTIONS)
744 }
745
746
move_container_values_except()747 void move_container_values_except() {
748 move_container_values_impl<noncopyable_movable_except_t>();
749 }
750
751 template <class T>
move_container_values_resetting_impl()752 void move_container_values_resetting_impl() {
753 typedef T noncopyable_movable_test_t;
754 CB_CONTAINER<noncopyable_movable_test_t> cb1(1);
755 noncopyable_movable_test_t var;
756 cb1.push_back();
757
758 cb1.push_back(boost::move(var));
759 BOOST_TEST(!cb1.back().is_moved());
760 BOOST_TEST(var.is_moved());
761 BOOST_TEST(cb1.size() == 1);
762 var = boost::move(cb1.back());
763 BOOST_TEST(cb1.back().is_moved());
764
765 cb1.push_front(boost::move(var));
766 BOOST_TEST(!cb1.front().is_moved());
767 BOOST_TEST(var.is_moved());
768 BOOST_TEST(cb1.size() == 1);
769 var = boost::move(cb1.back());
770 BOOST_TEST(cb1.back().is_moved());
771
772 cb1.push_back();
773 BOOST_TEST(!cb1.back().is_moved());
774 BOOST_TEST(cb1.size() == 1);
775 var = boost::move(cb1.back());
776 BOOST_TEST(cb1.back().is_moved());
777
778 cb1.push_front();
779 BOOST_TEST(!cb1.front().is_moved());
780 BOOST_TEST(cb1.size() == 1);
781 var = boost::move(cb1.back());
782 BOOST_TEST(cb1.back().is_moved());
783
784
785 cb1.insert(cb1.begin());
786 // If the circular_buffer is full and the pos points to begin(),
787 // then the item will not be inserted.
788 BOOST_TEST(cb1.front().is_moved());
789 BOOST_TEST(cb1.size() == 1);
790 var = boost::move(cb1.back());
791 BOOST_TEST(cb1.back().is_moved());
792
793 cb1.insert(cb1.begin(), boost::move(var));
794 // If the circular_buffer is full and the pos points to begin(),
795 // then the item will not be inserted.
796 BOOST_TEST(cb1.front().is_moved());
797 BOOST_TEST(cb1.size() == 1);
798 var = boost::move(cb1.back());
799 BOOST_TEST(cb1.back().is_moved());
800
801 cb1.rinsert(cb1.begin());
802 BOOST_TEST(!cb1.back().is_moved());
803 BOOST_TEST(cb1.size() == 1);
804 var = boost::move(cb1.back());
805 BOOST_TEST(cb1.back().is_moved());
806
807 var.reinit();
808 cb1.rinsert(cb1.begin(), boost::move(var));
809 BOOST_TEST(!cb1.back().is_moved());
810 BOOST_TEST(cb1.size() == 1);
811 var = boost::move(cb1.back());
812 BOOST_TEST(cb1.back().is_moved());
813
814 cb1.rinsert(cb1.end());
815 BOOST_TEST(cb1.back().is_moved());
816 BOOST_TEST(cb1.size() == 1);
817 var = boost::move(cb1.back());
818 BOOST_TEST(cb1.back().is_moved());
819
820 var.reinit();
821 cb1.rinsert(cb1.end(), boost::move(var));
822 BOOST_TEST(cb1.back().is_moved());
823 BOOST_TEST(cb1.size() == 1);
824 var = boost::move(cb1.back());
825 BOOST_TEST(cb1.back().is_moved());
826 cb1.push_back();
827 BOOST_TEST(!cb1[0].is_moved());
828
829 const int val = cb1[0].value();
830 cb1.linearize();
831 BOOST_TEST(!cb1[0].is_moved());
832 BOOST_TEST(cb1[0].value() == val);
833
834 cb1.rotate(cb1.begin());
835 BOOST_TEST(!cb1[0].is_moved());
836 BOOST_TEST(cb1[0].value() == val);
837 }
838
move_container_values_resetting_except()839 void move_container_values_resetting_except() {
840 move_container_values_resetting_impl<noncopyable_movable_except_t>();
841 }
842
move_container_values_resetting_noexcept()843 void move_container_values_resetting_noexcept() {
844 move_container_values_resetting_impl<noncopyable_movable_noexcept_t>();
845 }
846
847 // test main
main()848 int main()
849 {
850 run_common_tests();
851 iterator_constructor_and_assign_test();
852 iterator_reference_test();
853 iterator_difference_test();
854 iterator_increment_test();
855 iterator_decrement_test();
856 iterator_addition_test();
857 iterator_subtraction_test();
858 iterator_element_access_test();
859 iterator_comparison_test();
860 iterator_invalidation_test();
861 exception_safety_test();
862 move_container_values_except();
863 move_container_values_resetting_except();
864 move_container_values_resetting_noexcept();
865 return boost::report_errors();
866 }
867