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