]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | ||
92f5a8d4 TL |
28 | BOOST_TEST(itCopy == it); |
29 | BOOST_TEST(cit == it); | |
30 | BOOST_TEST(end1 == end2); | |
31 | BOOST_TEST(it != end1); | |
32 | BOOST_TEST(cit != end2); | |
7c673cae FG |
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 | ||
92f5a8d4 TL |
41 | BOOST_TEST((*it).m_n == Dummy::eVar); |
42 | BOOST_TEST((*it).fnc() == Dummy::eFnc); | |
43 | BOOST_TEST((*cit).const_fnc() == Dummy::eConst); | |
44 | BOOST_TEST((*it).virtual_fnc() == Dummy::eVirtual); | |
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); | |
7c673cae FG |
49 | } |
50 | ||
51 | void iterator_difference_test() { | |
52 | ||
53 | circular_buffer<MyInteger> cb(5, 1); | |
54 | cb.push_back(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 | ||
92f5a8d4 TL |
60 | BOOST_TEST(begin - begin == 0); |
61 | BOOST_TEST(end - cb.begin() == 5); | |
62 | BOOST_TEST(end - end == 0); | |
63 | BOOST_TEST(begin - cb.end() == -5); | |
64 | BOOST_TEST(it1 - cb.begin() == 2); | |
65 | BOOST_TEST(it1 - begin == 2); | |
66 | BOOST_TEST(end - it1 == 3); | |
67 | BOOST_TEST(it2 - it1 == 1); | |
68 | BOOST_TEST(it1 - it2 == -1); | |
69 | BOOST_TEST(it2 - it2 == 0); | |
7c673cae FG |
70 | } |
71 | ||
72 | void iterator_increment_test() { | |
73 | ||
74 | circular_buffer<MyInteger> cb(10, 1); | |
75 | cb.push_back(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 | ||
92f5a8d4 TL |
83 | BOOST_TEST(it1 == cb.begin() + 1); |
84 | BOOST_TEST(it2 == cb.begin() + 6); | |
85 | BOOST_TEST(it3 == cb.end()); | |
7c673cae FG |
86 | } |
87 | ||
88 | void iterator_decrement_test() { | |
89 | ||
90 | circular_buffer<MyInteger> cb(10, 1); | |
91 | cb.push_back(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 | ||
92f5a8d4 TL |
99 | BOOST_TEST(it1 == cb.end() - 1); |
100 | BOOST_TEST(it2 == cb.end() - 6); | |
101 | BOOST_TEST(it3 == cb.begin()); | |
7c673cae FG |
102 | } |
103 | ||
104 | void iterator_addition_test() { | |
105 | ||
106 | circular_buffer<MyInteger> cb(10, 1); | |
107 | cb.push_back(2); | |
108 | cb.push_back(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 | ||
92f5a8d4 TL |
118 | BOOST_TEST(it1 == 5 + cb.begin()); |
119 | BOOST_TEST(it2 == cb.end()); | |
120 | BOOST_TEST(it3 == cb.end()); | |
121 | BOOST_TEST(it4 + 3 == cb.end()); | |
122 | BOOST_TEST((-3) + it4 == cb.begin() + 4); | |
123 | BOOST_TEST(cb.begin() + 0 == cb.begin()); | |
7c673cae FG |
124 | } |
125 | ||
126 | void iterator_subtraction_test() { | |
127 | ||
128 | circular_buffer<MyInteger> cb(10, 1); | |
129 | cb.push_back(2); | |
130 | cb.push_back(2); | |
131 | cb.push_back(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 | ||
92f5a8d4 TL |
140 | BOOST_TEST(it1 == cb.begin() + 2); |
141 | BOOST_TEST(it2 == cb.end()); | |
142 | BOOST_TEST(it3 == cb.begin()); | |
143 | BOOST_TEST(it4 - 7 == cb.begin()); | |
144 | BOOST_TEST(it4 - (-3) == cb.end()); | |
145 | BOOST_TEST(cb.begin() - 0 == cb.begin()); | |
7c673cae FG |
146 | } |
147 | ||
148 | void iterator_element_access_test() { | |
149 | ||
150 | circular_buffer<MyInteger> cb(10); | |
151 | cb.push_back(1); | |
152 | cb.push_back(2); | |
153 | cb.push_back(3); | |
154 | cb.push_back(4); | |
155 | cb.push_back(5); | |
156 | cb.push_back(6); | |
157 | circular_buffer<MyInteger>::iterator it = cb.begin() + 1; | |
158 | ||
92f5a8d4 TL |
159 | BOOST_TEST(it[0] == 2); |
160 | BOOST_TEST(it[-1] == 1); | |
161 | BOOST_TEST(it[2] == 4); | |
7c673cae FG |
162 | } |
163 | ||
164 | void iterator_comparison_test() { | |
165 | ||
166 | circular_buffer<MyInteger> cb(5, 1); | |
167 | cb.push_back(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 | ||
92f5a8d4 TL |
172 | BOOST_TEST(begin == begin); |
173 | BOOST_TEST(end > cb.begin()); | |
174 | BOOST_TEST(begin < end); | |
175 | BOOST_TEST(end > begin); | |
176 | BOOST_TEST(end == end); | |
177 | BOOST_TEST(begin < cb.end()); | |
178 | BOOST_TEST(!(begin + 1 > cb.end())); | |
179 | BOOST_TEST(it > cb.begin()); | |
180 | BOOST_TEST(end > it); | |
181 | BOOST_TEST(begin >= begin); | |
182 | BOOST_TEST(end >= cb.begin()); | |
183 | BOOST_TEST(end <= end); | |
184 | BOOST_TEST(begin <= cb.end()); | |
185 | BOOST_TEST(it >= cb.begin()); | |
186 | BOOST_TEST(end >= it); | |
187 | BOOST_TEST(!(begin + 4 < begin + 4)); | |
188 | BOOST_TEST(begin + 4 < begin + 5); | |
189 | BOOST_TEST(!(begin + 5 < begin + 4)); | |
190 | BOOST_TEST(it < end - 1); | |
191 | BOOST_TEST(!(end - 1 < it)); | |
7c673cae FG |
192 | } |
193 | ||
194 | void iterator_invalidation_test() { | |
195 | ||
196 | #if BOOST_CB_ENABLE_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 | ||
92f5a8d4 TL |
205 | BOOST_TEST(it1.is_valid(0)); |
206 | BOOST_TEST(it2.is_valid(0)); | |
207 | BOOST_TEST(it3.is_valid(0)); | |
208 | BOOST_TEST(it4.is_valid(0)); | |
209 | BOOST_TEST(it5.is_valid(0)); | |
210 | BOOST_TEST(it6.is_valid(0)); | |
7c673cae FG |
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 | ||
92f5a8d4 TL |
223 | BOOST_TEST(it1.is_valid(&cb)); |
224 | BOOST_TEST(it2.is_valid(&ccb)); | |
225 | BOOST_TEST(it3.is_valid(&cb)); | |
226 | BOOST_TEST(it4.is_valid(&cb)); | |
227 | BOOST_TEST(it5.is_valid(&ccb)); | |
228 | BOOST_TEST(it6.is_valid(&cb)); | |
7c673cae FG |
229 | } |
230 | ||
92f5a8d4 TL |
231 | BOOST_TEST(it1.is_valid(0)); |
232 | BOOST_TEST(it2.is_valid(0)); | |
233 | BOOST_TEST(it3.is_valid(0)); | |
234 | BOOST_TEST(it4.is_valid(0)); | |
235 | BOOST_TEST(it5.is_valid(0)); | |
236 | BOOST_TEST(it6.is_valid(0)); | |
7c673cae FG |
237 | |
238 | circular_buffer<MyInteger> cb(10, 0); | |
239 | it1 = cb.end(); | |
240 | cb.clear(); | |
92f5a8d4 | 241 | BOOST_TEST(it1.is_valid(&cb)); |
7c673cae FG |
242 | cb.push_back(1); |
243 | cb.push_back(2); | |
244 | cb.push_back(3); | |
245 | int i = 0; | |
246 | for (it2 = cb.begin(); it2 != it1; it2++, i++); | |
92f5a8d4 | 247 | BOOST_TEST(i == 3); |
7c673cae FG |
248 | |
249 | circular_buffer<MyInteger> cb1(10, 0); | |
250 | circular_buffer<MyInteger> cb2(20, 0); | |
251 | it1 = cb1.end(); | |
252 | it2 = cb2.begin(); | |
92f5a8d4 TL |
253 | BOOST_TEST(it1.is_valid(&cb1)); |
254 | BOOST_TEST(it2.is_valid(&cb2)); | |
7c673cae FG |
255 | |
256 | cb1.swap(cb2); | |
92f5a8d4 TL |
257 | BOOST_TEST(!it1.is_valid(&cb1)); |
258 | BOOST_TEST(!it2.is_valid(&cb2)); | |
7c673cae FG |
259 | |
260 | it1 = cb1.begin() + 3; | |
261 | it2 = cb1.begin(); | |
262 | cb1.push_back(1); | |
92f5a8d4 TL |
263 | BOOST_TEST(it1.is_valid(&cb1)); |
264 | BOOST_TEST(!it2.is_valid(&cb1)); | |
265 | BOOST_TEST(*it2.m_it == 1); | |
7c673cae FG |
266 | |
267 | circular_buffer<MyInteger> cb3(5); | |
268 | cb3.push_back(1); | |
269 | cb3.push_back(2); | |
270 | cb3.push_back(3); | |
271 | cb3.push_back(4); | |
272 | cb3.push_back(5); | |
273 | it1 = cb3.begin() + 2; | |
274 | it2 = cb3.begin(); | |
275 | cb3.insert(cb3.begin() + 3, 6); | |
92f5a8d4 TL |
276 | BOOST_TEST(it1.is_valid(&cb3)); |
277 | BOOST_TEST(!it2.is_valid(&cb3)); | |
278 | BOOST_TEST(*it2.m_it == 5); | |
7c673cae FG |
279 | |
280 | it1 = cb3.begin() + 3; | |
281 | it2 = cb3.end() - 1; | |
282 | cb3.push_front(7); | |
92f5a8d4 TL |
283 | BOOST_TEST(it1.is_valid(&cb3)); |
284 | BOOST_TEST(!it2.is_valid(&cb3)); | |
285 | BOOST_TEST(*it2.m_it == 7); | |
7c673cae FG |
286 | |
287 | circular_buffer<MyInteger> cb4(5); | |
288 | cb4.push_back(1); | |
289 | cb4.push_back(2); | |
290 | cb4.push_back(3); | |
291 | cb4.push_back(4); | |
292 | cb4.push_back(5); | |
293 | it1 = cb4.begin() + 3; | |
294 | it2 = cb4.begin(); | |
295 | cb4.rinsert(cb4.begin() + 2, 6); | |
92f5a8d4 TL |
296 | BOOST_TEST(it1.is_valid(&cb4)); |
297 | BOOST_TEST(!it2.is_valid(&cb4)); | |
298 | BOOST_TEST(*it2.m_it == 2); | |
7c673cae FG |
299 | |
300 | it1 = cb1.begin() + 5; | |
301 | it2 = cb1.end() - 1; | |
302 | cb1.pop_back(); | |
92f5a8d4 TL |
303 | BOOST_TEST(it1.is_valid(&cb1)); |
304 | BOOST_TEST(!it2.is_valid(&cb1)); | |
7c673cae FG |
305 | |
306 | it1 = cb1.begin() + 5; | |
307 | it2 = cb1.begin(); | |
308 | cb1.pop_front(); | |
92f5a8d4 TL |
309 | BOOST_TEST(it1.is_valid(&cb1)); |
310 | BOOST_TEST(!it2.is_valid(&cb1)); | |
7c673cae FG |
311 | |
312 | circular_buffer<MyInteger> cb5(20, 0); | |
313 | it1 = cb5.begin() + 5; | |
314 | it2 = it3 = cb5.begin() + 15; | |
315 | cb5.erase(cb5.begin() + 10); | |
92f5a8d4 TL |
316 | BOOST_TEST(it1.is_valid(&cb5)); |
317 | BOOST_TEST(!it2.is_valid(&cb5)); | |
318 | BOOST_TEST(!it3.is_valid(&cb5)); | |
7c673cae FG |
319 | |
320 | it1 = cb5.begin() + 1; | |
321 | it2 = it3 = cb5.begin() + 8; | |
322 | cb5.erase(cb5.begin() + 3, cb5.begin() + 7); | |
92f5a8d4 TL |
323 | BOOST_TEST(it1.is_valid(&cb5)); |
324 | BOOST_TEST(!it2.is_valid(&cb5)); | |
325 | BOOST_TEST(!it3.is_valid(&cb5)); | |
7c673cae FG |
326 | |
327 | circular_buffer<MyInteger> cb6(20, 0); | |
328 | it4 = it1 = cb6.begin() + 5; | |
329 | it2 = cb6.begin() + 15; | |
330 | cb6.rerase(cb6.begin() + 10); | |
92f5a8d4 TL |
331 | BOOST_TEST(!it1.is_valid(&cb6)); |
332 | BOOST_TEST(!it4.is_valid(&cb6)); | |
333 | BOOST_TEST(it2.is_valid(&cb6)); | |
7c673cae FG |
334 | |
335 | it4 = it1 = cb6.begin() + 1; | |
336 | it2 = cb6.begin() + 8; | |
337 | cb6.rerase(cb6.begin() + 3, cb6.begin() + 7); | |
92f5a8d4 TL |
338 | BOOST_TEST(!it1.is_valid(&cb6)); |
339 | BOOST_TEST(!it4.is_valid(&cb6)); | |
340 | BOOST_TEST(it2.is_valid(&cb6)); | |
7c673cae FG |
341 | |
342 | circular_buffer<MyInteger> cb7(10, 1); | |
343 | cb7.push_back(2); | |
344 | cb7.push_back(3); | |
345 | cb7.push_back(4); | |
346 | it1 = cb7.end(); | |
347 | it2 = cb7.begin(); | |
348 | it3 = cb7.begin() + 6; | |
349 | cb7.linearize(); | |
92f5a8d4 TL |
350 | BOOST_TEST(it1.is_valid(&cb7)); |
351 | BOOST_TEST(!it2.is_valid(&cb7)); | |
352 | BOOST_TEST(!it3.is_valid(&cb7)); | |
7c673cae FG |
353 | it1 = cb7.end(); |
354 | it2 = cb7.begin(); | |
355 | it3 = cb7.begin() + 6; | |
356 | cb7.linearize(); | |
92f5a8d4 TL |
357 | BOOST_TEST(it1.is_valid(&cb7)); |
358 | BOOST_TEST(it2.is_valid(&cb7)); | |
359 | BOOST_TEST(it3.is_valid(&cb7)); | |
7c673cae FG |
360 | |
361 | cb7.push_back(5); | |
362 | cb7.push_back(6); | |
363 | it1 = cb7.end(); | |
364 | it2 = cb7.begin(); | |
365 | it3 = cb7.begin() + 6; | |
366 | cb7.set_capacity(10); | |
92f5a8d4 TL |
367 | BOOST_TEST(it1.is_valid(&cb7)); |
368 | BOOST_TEST(it2.is_valid(&cb7)); | |
369 | BOOST_TEST(it3.is_valid(&cb7)); | |
7c673cae | 370 | cb7.set_capacity(20); |
92f5a8d4 TL |
371 | BOOST_TEST(it1.is_valid(&cb7)); |
372 | BOOST_TEST(!it2.is_valid(&cb7)); | |
373 | BOOST_TEST(!it3.is_valid(&cb7)); | |
7c673cae FG |
374 | cb7.push_back(7); |
375 | it1 = cb7.end(); | |
376 | it2 = cb7.begin(); | |
377 | it3 = cb7.begin() + 6; | |
378 | cb7.set_capacity(10); | |
92f5a8d4 TL |
379 | BOOST_TEST(it1.is_valid(&cb7)); |
380 | BOOST_TEST(!it2.is_valid(&cb7)); | |
381 | BOOST_TEST(!it3.is_valid(&cb7)); | |
7c673cae FG |
382 | |
383 | cb7.push_back(8); | |
384 | cb7.push_back(9); | |
385 | it1 = cb7.end(); | |
386 | it2 = cb7.begin(); | |
387 | it3 = cb7.begin() + 6; | |
388 | cb7.rset_capacity(10); | |
92f5a8d4 TL |
389 | BOOST_TEST(it1.is_valid(&cb7)); |
390 | BOOST_TEST(it2.is_valid(&cb7)); | |
391 | BOOST_TEST(it3.is_valid(&cb7)); | |
7c673cae | 392 | cb7.rset_capacity(20); |
92f5a8d4 TL |
393 | BOOST_TEST(it1.is_valid(&cb7)); |
394 | BOOST_TEST(!it2.is_valid(&cb7)); | |
395 | BOOST_TEST(!it3.is_valid(&cb7)); | |
7c673cae FG |
396 | cb7.push_back(10); |
397 | it1 = cb7.end(); | |
398 | it2 = cb7.begin(); | |
399 | it3 = cb7.begin() + 6; | |
400 | cb7.rset_capacity(10); | |
92f5a8d4 TL |
401 | BOOST_TEST(it1.is_valid(&cb7)); |
402 | BOOST_TEST(!it2.is_valid(&cb7)); | |
403 | BOOST_TEST(!it3.is_valid(&cb7)); | |
7c673cae FG |
404 | |
405 | circular_buffer<MyInteger> cb8(10, 1); | |
406 | cb8.push_back(2); | |
407 | cb8.push_back(3); | |
408 | it1 = cb8.end(); | |
409 | it2 = cb8.begin(); | |
410 | it3 = cb8.begin() + 6; | |
411 | cb8.resize(10); | |
92f5a8d4 TL |
412 | BOOST_TEST(it1.is_valid(&cb8)); |
413 | BOOST_TEST(it2.is_valid(&cb8)); | |
414 | BOOST_TEST(it3.is_valid(&cb8)); | |
7c673cae | 415 | cb8.resize(20); |
92f5a8d4 TL |
416 | BOOST_TEST(it1.is_valid(&cb8)); |
417 | BOOST_TEST(!it2.is_valid(&cb8)); | |
418 | BOOST_TEST(!it3.is_valid(&cb8)); | |
7c673cae FG |
419 | cb8.push_back(4); |
420 | it1 = cb8.end(); | |
421 | it2 = cb8.begin(); | |
422 | it3 = cb8.begin() + 6; | |
423 | it4 = cb8.begin() + 12; | |
424 | cb8.resize(10); | |
92f5a8d4 TL |
425 | BOOST_TEST(it1.is_valid(&cb8)); |
426 | BOOST_TEST(it2.is_valid(&cb8)); | |
427 | BOOST_TEST(it3.is_valid(&cb8)); | |
428 | BOOST_TEST(!it4.is_valid(&cb8)); | |
7c673cae FG |
429 | |
430 | cb8.set_capacity(10); | |
431 | cb8.push_back(5); | |
432 | cb8.push_back(6); | |
433 | it1 = cb8.end(); | |
434 | it2 = cb8.begin(); | |
435 | it3 = cb8.begin() + 6; | |
436 | cb8.rresize(10); | |
92f5a8d4 TL |
437 | BOOST_TEST(it1.is_valid(&cb8)); |
438 | BOOST_TEST(it2.is_valid(&cb8)); | |
439 | BOOST_TEST(it3.is_valid(&cb8)); | |
7c673cae | 440 | cb8.rresize(20); |
92f5a8d4 TL |
441 | BOOST_TEST(it1.is_valid(&cb8)); |
442 | BOOST_TEST(!it2.is_valid(&cb8)); | |
443 | BOOST_TEST(!it3.is_valid(&cb8)); | |
7c673cae FG |
444 | cb8.push_back(7); |
445 | it1 = cb8.end(); | |
446 | it2 = cb8.begin(); | |
447 | it3 = cb8.begin() + 6; | |
448 | it4 = cb8.begin() + 12; | |
449 | cb8.rresize(10); | |
92f5a8d4 TL |
450 | BOOST_TEST(it1.is_valid(&cb8)); |
451 | BOOST_TEST(!it2.is_valid(&cb8)); | |
452 | BOOST_TEST(!it3.is_valid(&cb8)); | |
453 | BOOST_TEST(it4.is_valid(&cb8)); | |
7c673cae FG |
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; | |
92f5a8d4 TL |
461 | BOOST_TEST(it1.is_valid(&cb9)); |
462 | BOOST_TEST(!it2.is_valid(&cb9)); | |
463 | BOOST_TEST(!it3.is_valid(&cb9)); | |
464 | BOOST_TEST(!it4.is_valid(&cb9)); | |
7c673cae FG |
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(5, 2); | |
92f5a8d4 TL |
472 | BOOST_TEST(it1.is_valid(&cb10)); |
473 | BOOST_TEST(!it2.is_valid(&cb10)); | |
474 | BOOST_TEST(!it3.is_valid(&cb10)); | |
475 | BOOST_TEST(!it4.is_valid(&cb10)); | |
7c673cae FG |
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(15, 5, 2); | |
92f5a8d4 TL |
483 | BOOST_TEST(it1.is_valid(&cb11)); |
484 | BOOST_TEST(!it2.is_valid(&cb11)); | |
485 | BOOST_TEST(!it3.is_valid(&cb11)); | |
486 | BOOST_TEST(!it4.is_valid(&cb11)); | |
7c673cae FG |
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(cb11.begin(), cb11.end()); | |
92f5a8d4 TL |
494 | BOOST_TEST(it1.is_valid(&cb12)); |
495 | BOOST_TEST(!it2.is_valid(&cb12)); | |
496 | BOOST_TEST(!it3.is_valid(&cb12)); | |
497 | BOOST_TEST(!it4.is_valid(&cb12)); | |
7c673cae FG |
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(15, cb11.begin(), cb11.end()); | |
92f5a8d4 TL |
505 | BOOST_TEST(it1.is_valid(&cb13)); |
506 | BOOST_TEST(!it2.is_valid(&cb13)); | |
507 | BOOST_TEST(!it3.is_valid(&cb13)); | |
508 | BOOST_TEST(!it4.is_valid(&cb13)); | |
7c673cae FG |
509 | |
510 | circular_buffer<MyInteger> cb14(10); | |
511 | cb14.push_back(1); | |
512 | cb14.push_back(2); | |
513 | cb14.push_back(3); | |
514 | cb14.push_back(4); | |
515 | cb14.push_back(5); | |
516 | cb14.push_back(6); | |
517 | cb14.push_back(7); | |
518 | it1 = cb14.end(); | |
519 | it2 = cb14.begin() + 2; | |
520 | it3 = cb14.begin() + 1; | |
521 | it4 = cb14.begin() + 5; | |
522 | cb14.rotate(it2); | |
92f5a8d4 TL |
523 | BOOST_TEST(it1.is_valid(&cb14)); |
524 | BOOST_TEST(it2.is_valid(&cb14)); | |
525 | BOOST_TEST(!it3.is_valid(&cb14)); | |
526 | BOOST_TEST(it4.is_valid(&cb14)); | |
7c673cae FG |
527 | |
528 | circular_buffer<MyInteger> cb15(7); | |
529 | cb15.push_back(1); | |
530 | cb15.push_back(2); | |
531 | cb15.push_back(3); | |
532 | cb15.push_back(4); | |
533 | cb15.push_back(5); | |
534 | cb15.push_back(6); | |
535 | cb15.push_back(7); | |
536 | cb15.push_back(8); | |
537 | cb15.push_back(9); | |
538 | it1 = cb15.end(); | |
539 | it2 = cb15.begin() + 2; | |
540 | it3 = cb15.begin() + 1; | |
541 | it4 = cb15.begin() + 5; | |
542 | cb15.rotate(it3); | |
92f5a8d4 TL |
543 | BOOST_TEST(it1.is_valid(&cb15)); |
544 | BOOST_TEST(it2.is_valid(&cb15)); | |
545 | BOOST_TEST(it3.is_valid(&cb15)); | |
546 | BOOST_TEST(it4.is_valid(&cb15)); | |
7c673cae FG |
547 | |
548 | circular_buffer<MyInteger> cb16(10); | |
549 | cb16.push_back(1); | |
550 | cb16.push_back(2); | |
551 | cb16.push_back(3); | |
552 | cb16.push_back(4); | |
553 | cb16.push_back(5); | |
554 | cb16.push_back(6); | |
555 | cb16.push_back(7); | |
556 | it1 = cb16.end(); | |
557 | it2 = cb16.begin() + 6; | |
558 | it3 = cb16.begin(); | |
559 | it4 = cb16.begin() + 5; | |
560 | cb16.rotate(it4); | |
92f5a8d4 TL |
561 | BOOST_TEST(it1.is_valid(&cb16)); |
562 | BOOST_TEST(!it2.is_valid(&cb16)); | |
563 | BOOST_TEST(it3.is_valid(&cb16)); | |
564 | BOOST_TEST(!it4.is_valid(&cb16)); | |
7c673cae FG |
565 | |
566 | #endif // #if BOOST_CB_ENABLE_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); | |
92f5a8d4 TL |
576 | BOOST_TEST_THROWS(cb1.set_capacity(5), std::exception); |
577 | BOOST_TEST(cb1.capacity() == 3); | |
7c673cae | 578 | MyInteger::set_exception_trigger(3); |
92f5a8d4 TL |
579 | BOOST_TEST_THROWS(cb1.rset_capacity(5), std::exception); |
580 | BOOST_TEST(cb1.capacity() == 3); | |
7c673cae FG |
581 | generic_test(cb1); |
582 | ||
583 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 584 | BOOST_TEST_THROWS(circular_buffer<MyInteger> cb2(5, 10), std::exception); |
7c673cae FG |
585 | |
586 | circular_buffer<MyInteger> cb3(5, 10); | |
587 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 588 | BOOST_TEST_THROWS(circular_buffer<MyInteger> cb4(cb3), std::exception); |
7c673cae FG |
589 | |
590 | vector<MyInteger> v(5, MyInteger(10)); | |
591 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 592 | BOOST_TEST_THROWS(circular_buffer<MyInteger> cb5(8, v.begin(), v.end()), std::exception); |
7c673cae FG |
593 | |
594 | circular_buffer<MyInteger> cb6(5, 10); | |
595 | circular_buffer<MyInteger> cb7(8, 3); | |
596 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 TL |
597 | BOOST_TEST_THROWS(cb7 = cb6, std::exception); |
598 | BOOST_TEST(cb7.size() == 8); | |
599 | BOOST_TEST(cb7.capacity() == 8); | |
600 | BOOST_TEST(cb7[0] == 3); | |
601 | BOOST_TEST(cb7[7] == 3); | |
7c673cae FG |
602 | generic_test(cb7); |
603 | ||
604 | circular_buffer<MyInteger> cb8(5, 10); | |
605 | MyInteger::set_exception_trigger(2); | |
92f5a8d4 | 606 | BOOST_TEST_THROWS(cb8.push_front(1), std::exception); |
7c673cae FG |
607 | |
608 | circular_buffer<MyInteger> cb9(5); | |
609 | cb9.push_back(1); | |
610 | cb9.push_back(2); | |
611 | cb9.push_back(3); | |
612 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 613 | BOOST_TEST_THROWS(cb9.insert(cb9.begin() + 1, 4), std::exception); |
7c673cae FG |
614 | |
615 | circular_buffer<MyInteger> cb10(5); | |
616 | cb10.push_back(1); | |
617 | cb10.push_back(2); | |
618 | cb10.push_back(3); | |
619 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 620 | BOOST_TEST_THROWS(cb10.rinsert(cb10.begin() + 1, 4), std::exception); |
7c673cae FG |
621 | |
622 | circular_buffer<MyInteger> cb11(5); | |
623 | cb11.push_back(1); | |
624 | cb11.push_back(2); | |
625 | MyInteger::set_exception_trigger(2); | |
92f5a8d4 | 626 | BOOST_TEST_THROWS(cb11.rinsert(cb11.begin(), 1), std::exception); |
7c673cae FG |
627 | |
628 | circular_buffer<MyInteger> cb12(5, 1); | |
629 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 630 | BOOST_TEST_THROWS(cb12.assign(4, 2), std::exception); |
7c673cae FG |
631 | |
632 | circular_buffer<MyInteger> cb13(5, 1); | |
633 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 634 | BOOST_TEST_THROWS(cb13.assign(6, 2), std::exception); |
7c673cae FG |
635 | |
636 | circular_buffer<MyInteger> cb14(5); | |
637 | cb14.push_back(1); | |
638 | cb14.push_back(2); | |
639 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 640 | BOOST_TEST_THROWS(cb14.insert(cb14.begin(), 10, 3), std::exception); |
7c673cae FG |
641 | |
642 | circular_buffer<MyInteger> cb15(5); | |
643 | cb15.push_back(1); | |
644 | cb15.push_back(2); | |
645 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 646 | BOOST_TEST_THROWS(cb15.insert(cb15.end(), 10, 3), std::exception); |
7c673cae FG |
647 | |
648 | circular_buffer<MyInteger> cb16(5); | |
649 | cb16.push_back(1); | |
650 | cb16.push_back(2); | |
651 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 652 | BOOST_TEST_THROWS(cb16.rinsert(cb16.begin(), 10, 3), std::exception); |
7c673cae FG |
653 | |
654 | circular_buffer<MyInteger> cb17(5); | |
655 | cb17.push_back(1); | |
656 | cb17.push_back(2); | |
657 | MyInteger::set_exception_trigger(3); | |
92f5a8d4 | 658 | BOOST_TEST_THROWS(cb17.rinsert(cb17.end(), 10, 3), std::exception); |
7c673cae FG |
659 | |
660 | circular_buffer<MyInteger> cb18(5, 0); | |
661 | cb18.push_back(1); | |
662 | cb18.push_back(2); | |
663 | cb18.pop_front(); | |
664 | MyInteger::set_exception_trigger(4); | |
92f5a8d4 | 665 | BOOST_TEST_THROWS(cb18.linearize(), std::exception); |
7c673cae FG |
666 | |
667 | circular_buffer<MyInteger> cb19(5, 0); | |
668 | cb19.push_back(1); | |
669 | cb19.push_back(2); | |
670 | MyInteger::set_exception_trigger(5); | |
92f5a8d4 | 671 | BOOST_TEST_THROWS(cb19.linearize(), std::exception); |
7c673cae FG |
672 | |
673 | circular_buffer<MyInteger> cb20(5, 0); | |
674 | cb20.push_back(1); | |
675 | cb20.push_back(2); | |
676 | MyInteger::set_exception_trigger(6); | |
92f5a8d4 | 677 | BOOST_TEST_THROWS(cb20.linearize(), std::exception); |
7c673cae FG |
678 | |
679 | circular_buffer<MyInteger> cb21(5); | |
680 | cb21.push_back(1); | |
681 | cb21.push_back(2); | |
682 | cb21.push_back(3); | |
683 | MyInteger::set_exception_trigger(2); | |
92f5a8d4 | 684 | BOOST_TEST_THROWS(cb21.insert(cb21.begin() + 1, 4), std::exception); |
7c673cae FG |
685 | |
686 | circular_buffer<MyInteger> cb22(5); | |
687 | cb22.push_back(1); | |
688 | cb22.push_back(2); | |
689 | cb22.push_back(3); | |
690 | MyInteger::set_exception_trigger(2); | |
92f5a8d4 | 691 | BOOST_TEST_THROWS(cb22.insert(cb22.end(), 4), std::exception); |
7c673cae FG |
692 | |
693 | circular_buffer<MyInteger> cb23(5, 0); | |
694 | MyInteger::set_exception_trigger(2); | |
92f5a8d4 | 695 | BOOST_TEST_THROWS(cb23.insert(cb23.begin() + 1, 4), std::exception); |
7c673cae FG |
696 | |
697 | circular_buffer<MyInteger> cb24(5); | |
698 | cb24.push_back(1); | |
699 | cb24.push_back(2); | |
700 | cb24.push_back(3); | |
701 | MyInteger::set_exception_trigger(2); | |
92f5a8d4 | 702 | BOOST_TEST_THROWS(cb24.rinsert(cb24.begin() + 1, 4), std::exception); |
7c673cae FG |
703 | |
704 | circular_buffer<MyInteger> cb25(5, 0); | |
705 | MyInteger::set_exception_trigger(2); | |
92f5a8d4 | 706 | BOOST_TEST_THROWS(cb25.rinsert(cb25.begin() + 3, 4), std::exception); |
7c673cae FG |
707 | |
708 | circular_buffer<MyInteger> cb26(5); | |
709 | cb26.push_back(1); | |
710 | cb26.push_back(2); | |
711 | MyInteger::set_exception_trigger(5); | |
92f5a8d4 | 712 | BOOST_TEST_THROWS(cb26.insert(cb26.begin(), 10, 3), std::exception); |
7c673cae FG |
713 | |
714 | circular_buffer<MyInteger> cb27(5); | |
715 | cb27.push_back(1); | |
716 | cb27.push_back(2); | |
717 | MyInteger::set_exception_trigger(5); | |
92f5a8d4 | 718 | BOOST_TEST_THROWS(cb27.insert(cb27.end(), 10, 3), std::exception); |
7c673cae FG |
719 | |
720 | circular_buffer<MyInteger> cb28(5); | |
721 | cb28.push_back(1); | |
722 | cb28.push_back(2); | |
723 | MyInteger::set_exception_trigger(5); | |
92f5a8d4 | 724 | BOOST_TEST_THROWS(cb28.rinsert(cb28.begin(), 10, 3), std::exception); |
7c673cae FG |
725 | |
726 | circular_buffer<MyInteger> cb29(5); | |
727 | cb29.push_back(1); | |
728 | cb29.push_back(2); | |
729 | MyInteger::set_exception_trigger(5); | |
92f5a8d4 | 730 | BOOST_TEST_THROWS(cb29.rinsert(cb29.end(), 10, 3), std::exception); |
7c673cae FG |
731 | |
732 | circular_buffer<MyInteger> cb30(10); | |
733 | cb30.push_back(1); | |
734 | cb30.push_back(2); | |
735 | cb30.push_back(3); | |
736 | MyInteger::set_exception_trigger(2); | |
92f5a8d4 | 737 | BOOST_TEST_THROWS(cb30.rinsert(cb30.begin(), 10, 3), std::exception); |
7c673cae FG |
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)); | |
92f5a8d4 TL |
755 | BOOST_TEST(!cb1.back().is_moved()); |
756 | BOOST_TEST(var.is_moved()); | |
757 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 758 | var = boost::move(cb1.back()); |
92f5a8d4 | 759 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
760 | |
761 | cb1.push_front(boost::move(var)); | |
92f5a8d4 TL |
762 | BOOST_TEST(!cb1.front().is_moved()); |
763 | BOOST_TEST(var.is_moved()); | |
764 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 765 | var = boost::move(cb1.back()); |
92f5a8d4 | 766 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
767 | |
768 | cb1.push_back(); | |
92f5a8d4 TL |
769 | BOOST_TEST(!cb1.back().is_moved()); |
770 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 771 | var = boost::move(cb1.back()); |
92f5a8d4 | 772 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
773 | |
774 | cb1.push_front(); | |
92f5a8d4 TL |
775 | BOOST_TEST(!cb1.front().is_moved()); |
776 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 777 | var = boost::move(cb1.back()); |
92f5a8d4 | 778 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
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. | |
92f5a8d4 TL |
784 | BOOST_TEST(cb1.front().is_moved()); |
785 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 786 | var = boost::move(cb1.back()); |
92f5a8d4 | 787 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
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. | |
92f5a8d4 TL |
792 | BOOST_TEST(cb1.front().is_moved()); |
793 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 794 | var = boost::move(cb1.back()); |
92f5a8d4 | 795 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
796 | |
797 | cb1.rinsert(cb1.begin()); | |
92f5a8d4 TL |
798 | BOOST_TEST(!cb1.back().is_moved()); |
799 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 800 | var = boost::move(cb1.back()); |
92f5a8d4 | 801 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
802 | |
803 | var.reinit(); | |
804 | cb1.rinsert(cb1.begin(), boost::move(var)); | |
92f5a8d4 TL |
805 | BOOST_TEST(!cb1.back().is_moved()); |
806 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 807 | var = boost::move(cb1.back()); |
92f5a8d4 | 808 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
809 | |
810 | cb1.rinsert(cb1.end()); | |
92f5a8d4 TL |
811 | BOOST_TEST(cb1.back().is_moved()); |
812 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 813 | var = boost::move(cb1.back()); |
92f5a8d4 | 814 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae FG |
815 | |
816 | var.reinit(); | |
817 | cb1.rinsert(cb1.end(), boost::move(var)); | |
92f5a8d4 TL |
818 | BOOST_TEST(cb1.back().is_moved()); |
819 | BOOST_TEST(cb1.size() == 1); | |
7c673cae | 820 | var = boost::move(cb1.back()); |
92f5a8d4 | 821 | BOOST_TEST(cb1.back().is_moved()); |
7c673cae | 822 | cb1.push_back(); |
92f5a8d4 | 823 | BOOST_TEST(!cb1[0].is_moved()); |
7c673cae FG |
824 | |
825 | const int val = cb1[0].value(); | |
826 | cb1.linearize(); | |
92f5a8d4 TL |
827 | BOOST_TEST(!cb1[0].is_moved()); |
828 | BOOST_TEST(cb1[0].value() == val); | |
7c673cae FG |
829 | |
830 | cb1.rotate(cb1.begin()); | |
92f5a8d4 TL |
831 | BOOST_TEST(!cb1[0].is_moved()); |
832 | BOOST_TEST(cb1[0].value() == val); | |
7c673cae FG |
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 | |
92f5a8d4 TL |
844 | int main() |
845 | { | |
846 | run_common_tests(); | |
847 | iterator_constructor_and_assign_test(); | |
848 | iterator_reference_test(); | |
849 | iterator_difference_test(); | |
850 | iterator_increment_test(); | |
851 | iterator_decrement_test(); | |
852 | iterator_addition_test(); | |
853 | iterator_subtraction_test(); | |
854 | iterator_element_access_test(); | |
855 | iterator_comparison_test(); | |
856 | iterator_invalidation_test(); | |
857 | exception_safety_test(); | |
858 | move_container_values_except(); | |
859 | move_container_values_resetting_except(); | |
860 | move_container_values_resetting_noexcept(); | |
861 | return boost::report_errors(); | |
7c673cae | 862 | } |