]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Demonstration of rules when an iterator is considered to be valid if the soft |
2 | // iterator invalidation definition is applied. | |
3 | // Note: The soft iterator invalidation definition CAN NOT be applied | |
4 | // to the space optimized circular buffer. | |
5 | ||
6 | // Copyright (c) 2003-2008 Jan Gaspar | |
7 | ||
8 | // Use, modification, and distribution is subject to the Boost Software | |
9 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
10 | // http://www.boost.org/LICENSE_1_0.txt) | |
11 | ||
12 | #include "test.hpp" | |
13 | ||
14 | // test of the example (introduced in the documentation) | |
15 | void validity_example_test() { | |
16 | ||
17 | circular_buffer<int> cb(3); | |
18 | ||
19 | cb.push_back(1); | |
20 | cb.push_back(2); | |
21 | cb.push_back(3); | |
22 | ||
23 | circular_buffer<int>::iterator it = cb.begin(); | |
24 | ||
92f5a8d4 | 25 | BOOST_TEST(*it == 1); |
7c673cae FG |
26 | |
27 | cb.push_back(4); | |
28 | ||
92f5a8d4 | 29 | BOOST_TEST(*it == 4); |
7c673cae FG |
30 | } |
31 | ||
32 | void validity_insert_test() { | |
33 | ||
34 | int array[] = { 1, 2, 3 }; | |
35 | ||
36 | // memory placement: { 1, 2, 3 } | |
37 | // circular buffer: { 1, 2, 3 } | |
38 | circular_buffer<int> cb(4, array, array + 3); | |
39 | ||
40 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
41 | circular_buffer<int>::iterator it1 = cb.begin(); | |
42 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
43 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
44 | ||
45 | cb.insert(cb.begin() + 1, 4); | |
46 | ||
47 | // memory placement: { 1, 4, 2, 3 } | |
48 | // circular buffer: { 1, 4, 2, 3 } | |
92f5a8d4 TL |
49 | BOOST_TEST(*it1 == 1); |
50 | BOOST_TEST(*it2 == 4); | |
51 | BOOST_TEST(*it3 == 2); | |
52 | BOOST_TEST(cb[0] == 1); | |
53 | BOOST_TEST(cb[1] == 4); | |
54 | BOOST_TEST(cb[2] == 2); | |
55 | BOOST_TEST(cb[3] == 3); | |
7c673cae FG |
56 | |
57 | // it4 -> 3 | |
58 | circular_buffer<int>::iterator it4 = it1 + 3; | |
59 | ||
60 | cb.insert(cb.begin() + 1, 5); | |
61 | ||
62 | // memory placement: { 3, 5, 4, 2 } | |
63 | // circular buffer: { 5, 4, 2, 3 } | |
92f5a8d4 TL |
64 | BOOST_TEST(*it1 == 3); |
65 | BOOST_TEST(*it2 == 5); | |
66 | BOOST_TEST(*it3 == 4); | |
67 | BOOST_TEST(*it4 == 2); | |
68 | BOOST_TEST(cb[0] == 5); | |
69 | BOOST_TEST(cb[1] == 4); | |
70 | BOOST_TEST(cb[2] == 2); | |
71 | BOOST_TEST(cb[3] == 3); | |
7c673cae FG |
72 | } |
73 | ||
74 | void validity_insert_n_test() { | |
75 | ||
76 | // memory placement: { 1, 2, 3 } | |
77 | // circular buffer: { 1, 2, 3 } | |
78 | circular_buffer<int> cb(5); | |
79 | cb.push_back(1); | |
80 | cb.push_back(2); | |
81 | cb.push_back(3); | |
82 | ||
83 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
84 | circular_buffer<int>::iterator it1 = cb.begin(); | |
85 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
86 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
87 | ||
88 | cb.insert(cb.begin() + 1, 2, 4); | |
89 | ||
90 | // memory placement: { 1, 4, 4, 2, 3 } | |
91 | // circular buffer: { 1, 4, 4, 2, 3 } | |
92f5a8d4 TL |
92 | BOOST_TEST(*it1 == 1); |
93 | BOOST_TEST(*it2 == 4); | |
94 | BOOST_TEST(*it3 == 4); | |
95 | BOOST_TEST(cb[0] == 1); | |
96 | BOOST_TEST(cb[1] == 4); | |
97 | BOOST_TEST(cb[2] == 4); | |
98 | BOOST_TEST(cb[3] == 2); | |
99 | BOOST_TEST(cb[4] == 3); | |
7c673cae FG |
100 | |
101 | // it4 -> 2, it5 -> 3 | |
102 | circular_buffer<int>::iterator it4 = it1 + 3; | |
103 | circular_buffer<int>::iterator it5 = it1 + 4; | |
104 | ||
105 | cb.insert(cb.begin() + 1, 2, 5); | |
106 | ||
107 | // memory placement: { 3, 5, 4, 4, 2 } - 5 inserted only once | |
108 | // circular buffer: { 5, 4, 4, 2, 3 } | |
92f5a8d4 TL |
109 | BOOST_TEST(*it1 == 3); |
110 | BOOST_TEST(*it2 == 5); | |
111 | BOOST_TEST(*it3 == 4); | |
112 | BOOST_TEST(*it4 == 4); | |
113 | BOOST_TEST(*it5 == 2); | |
114 | BOOST_TEST(cb[0] == 5); | |
115 | BOOST_TEST(cb[1] == 4); | |
116 | BOOST_TEST(cb[2] == 4); | |
117 | BOOST_TEST(cb[3] == 2); | |
118 | BOOST_TEST(cb[4] == 3); | |
7c673cae FG |
119 | } |
120 | ||
121 | void validity_insert_range_test() { | |
122 | ||
123 | vector<int> v1; | |
124 | v1.push_back(4); | |
125 | v1.push_back(5); | |
126 | ||
127 | vector<int> v2; | |
128 | v2.push_back(6); | |
129 | v2.push_back(7); | |
130 | ||
131 | ||
132 | // memory placement: { 1, 2, 3 } | |
133 | // circular buffer: { 1, 2, 3 } | |
134 | circular_buffer<int> cb1(5); | |
135 | cb1.push_back(1); | |
136 | cb1.push_back(2); | |
137 | cb1.push_back(3); | |
138 | ||
139 | // it11 -> 1, it12 -> 2, it13 -> 3 | |
140 | circular_buffer<int>::iterator it11 = cb1.begin(); | |
141 | circular_buffer<int>::iterator it12 = cb1.begin() + 1; | |
142 | circular_buffer<int>::iterator it13 = cb1.begin() + 2; | |
143 | ||
144 | cb1.insert(cb1.begin() + 1, v1.begin(), v1.end()); | |
145 | ||
146 | // memory placement: { 1, 4, 5, 2, 3 } | |
147 | // circular buffer: { 1, 4, 5, 2, 3 } | |
92f5a8d4 TL |
148 | BOOST_TEST(*it11 == 1); |
149 | BOOST_TEST(*it12 == 4); | |
150 | BOOST_TEST(*it13 == 5); | |
151 | BOOST_TEST(cb1[0] == 1); | |
152 | BOOST_TEST(cb1[1] == 4); | |
153 | BOOST_TEST(cb1[2] == 5); | |
154 | BOOST_TEST(cb1[3] == 2); | |
155 | BOOST_TEST(cb1[4] == 3); | |
7c673cae FG |
156 | |
157 | // it14 -> 2, it15 -> 3 | |
158 | circular_buffer<int>::iterator it14 = it11 + 3; | |
159 | circular_buffer<int>::iterator it15 = it11 + 4; | |
160 | ||
161 | cb1.insert(cb1.begin() + 1, v2.begin(), v2.end()); | |
162 | ||
163 | // memory placement: { 3, 7, 4, 5, 2 } - 7 inserted only | |
164 | // circular buffer: { 7, 4, 5, 2, 3 } | |
92f5a8d4 TL |
165 | BOOST_TEST(*it11 == 3); |
166 | BOOST_TEST(*it12 == 7); | |
167 | BOOST_TEST(*it13 == 4); | |
168 | BOOST_TEST(*it14 == 5); | |
169 | BOOST_TEST(*it15 == 2); | |
170 | BOOST_TEST(cb1[0] == 7); | |
171 | BOOST_TEST(cb1[1] == 4); | |
172 | BOOST_TEST(cb1[2] == 5); | |
173 | BOOST_TEST(cb1[3] == 2); | |
174 | BOOST_TEST(cb1[4] == 3); | |
7c673cae FG |
175 | |
176 | // memory placement: { 1, 2, 3 } | |
177 | // circular buffer: { 1, 2, 3 } | |
178 | circular_buffer<int> cb2(5); | |
179 | cb2.push_back(1); | |
180 | cb2.push_back(2); | |
181 | cb2.push_back(3); | |
182 | ||
183 | // it21 -> 1, it22 -> 2, it23 -> 3 | |
184 | circular_buffer<int>::iterator it21 = cb2.begin(); | |
185 | circular_buffer<int>::iterator it22 = cb2.begin() + 1; | |
186 | circular_buffer<int>::iterator it23 = cb2.begin() + 2; | |
187 | ||
188 | cb2.insert(cb2.begin() + 1, MyInputIterator(v1.begin()), MyInputIterator(v1.end())); | |
189 | ||
190 | // memory placement: { 1, 4, 5, 2, 3 } | |
191 | // circular buffer: { 1, 4, 5, 2, 3 } | |
92f5a8d4 TL |
192 | BOOST_TEST(*it21 == 1); |
193 | BOOST_TEST(*it22 == 4); | |
194 | BOOST_TEST(*it23 == 5); | |
195 | BOOST_TEST(cb2[0] == 1); | |
196 | BOOST_TEST(cb2[1] == 4); | |
197 | BOOST_TEST(cb2[2] == 5); | |
198 | BOOST_TEST(cb2[3] == 2); | |
199 | BOOST_TEST(cb2[4] == 3); | |
7c673cae FG |
200 | |
201 | // it24 -> 2, it25 -> 3 | |
202 | circular_buffer<int>::iterator it24 = it21 + 3; | |
203 | circular_buffer<int>::iterator it25 = it21 + 4; | |
204 | ||
205 | cb2.insert(cb2.begin() + 1, MyInputIterator(v2.begin()), MyInputIterator(v2.end())); | |
206 | ||
207 | // memory placement: { 2, 3, 7, 4, 5 } - using input iterator inserts all items even if they are later replaced | |
208 | // circular buffer: { 7, 4, 5, 2, 3 } | |
92f5a8d4 TL |
209 | BOOST_TEST(*it21 == 2); |
210 | BOOST_TEST(*it22 == 3); | |
211 | BOOST_TEST(*it23 == 7); | |
212 | BOOST_TEST(*it24 == 4); | |
213 | BOOST_TEST(*it25 == 5); | |
214 | BOOST_TEST(cb2[0] == 7); | |
215 | BOOST_TEST(cb2[1] == 4); | |
216 | BOOST_TEST(cb2[2] == 5); | |
217 | BOOST_TEST(cb2[3] == 2); | |
218 | BOOST_TEST(cb2[4] == 3); | |
7c673cae FG |
219 | } |
220 | ||
221 | void validity_rinsert_test() { | |
222 | ||
223 | int array[] = { 1, 2, 3 }; | |
224 | ||
225 | // memory placement: { 1, 2, 3 } | |
226 | // circular buffer: { 1, 2, 3 } | |
227 | circular_buffer<int> cb(4, array, array + 3); | |
228 | ||
229 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
230 | circular_buffer<int>::iterator it1 = cb.begin(); | |
231 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
232 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
233 | ||
234 | cb.rinsert(cb.begin() + 2, 4); | |
235 | ||
236 | // memory placement: { 2, 4, 3, 1 } | |
237 | // circular buffer: { 1, 2, 4, 3 } | |
92f5a8d4 TL |
238 | BOOST_TEST(*it1 == 2); |
239 | BOOST_TEST(*it2 == 4); | |
240 | BOOST_TEST(*it3 == 3); | |
241 | BOOST_TEST(cb[0] == 1); | |
242 | BOOST_TEST(cb[1] == 2); | |
243 | BOOST_TEST(cb[2] == 4); | |
244 | BOOST_TEST(cb[3] == 3); | |
7c673cae FG |
245 | |
246 | // it4 -> 1 | |
247 | circular_buffer<int>::iterator it4 = it1 - 1; | |
248 | ||
249 | cb.rinsert(cb.begin() + 2, 5); | |
250 | ||
251 | // memory placement: { 5, 4, 1, 2 } | |
252 | // circular buffer: { 1, 2, 5, 4 } | |
92f5a8d4 TL |
253 | BOOST_TEST(*it1 == 5); |
254 | BOOST_TEST(*it2 == 4); | |
255 | BOOST_TEST(*it3 == 1); | |
256 | BOOST_TEST(*it4 == 2); | |
257 | BOOST_TEST(cb[0] == 1); | |
258 | BOOST_TEST(cb[1] == 2); | |
259 | BOOST_TEST(cb[2] == 5); | |
260 | BOOST_TEST(cb[3] == 4); | |
7c673cae FG |
261 | } |
262 | ||
263 | void validity_rinsert_n_test() { | |
264 | ||
265 | // memory placement: { 1, 2, 3 } | |
266 | // circular buffer: { 1, 2, 3 } | |
267 | circular_buffer<int> cb(5); | |
268 | cb.push_back(1); | |
269 | cb.push_back(2); | |
270 | cb.push_back(3); | |
271 | ||
272 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
273 | circular_buffer<int>::iterator it1 = cb.begin(); | |
274 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
275 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
276 | ||
277 | cb.rinsert(cb.begin() + 2, 2, 4); | |
278 | ||
279 | // memory placement: { 4, 4, 3, 1, 2 } | |
280 | // circular buffer: { 1, 2, 4, 4, 3 } | |
92f5a8d4 TL |
281 | BOOST_TEST(*it1 == 4); |
282 | BOOST_TEST(*it2 == 4); | |
283 | BOOST_TEST(*it3 == 3); | |
284 | BOOST_TEST(cb[0] == 1); | |
285 | BOOST_TEST(cb[1] == 2); | |
286 | BOOST_TEST(cb[2] == 4); | |
287 | BOOST_TEST(cb[3] == 4); | |
288 | BOOST_TEST(cb[4] == 3); | |
7c673cae FG |
289 | |
290 | // it4 -> 1, it5 -> 2 | |
291 | circular_buffer<int>::iterator it4 = it1 - 2; | |
292 | circular_buffer<int>::iterator it5 = it1 - 1; | |
293 | ||
294 | cb.rinsert(cb.begin() + 4, 2, 5); | |
295 | ||
296 | // memory placement: { 4, 5, 1, 2, 4 } - 5 inserted only once | |
297 | // circular buffer: { 1, 2, 4, 4, 5 } | |
92f5a8d4 TL |
298 | BOOST_TEST(*it1 == 4); |
299 | BOOST_TEST(*it2 == 5); | |
300 | BOOST_TEST(*it3 == 1); | |
301 | BOOST_TEST(*it4 == 2); | |
302 | BOOST_TEST(*it5 == 4); | |
303 | BOOST_TEST(cb[0] == 1); | |
304 | BOOST_TEST(cb[1] == 2); | |
305 | BOOST_TEST(cb[2] == 4); | |
306 | BOOST_TEST(cb[3] == 4); | |
307 | BOOST_TEST(cb[4] == 5); | |
7c673cae FG |
308 | } |
309 | ||
310 | void validity_rinsert_range_test() { | |
311 | ||
312 | vector<int> v1; | |
313 | v1.push_back(4); | |
314 | v1.push_back(5); | |
315 | ||
316 | vector<int> v2; | |
317 | v2.push_back(6); | |
318 | v2.push_back(7); | |
319 | ||
320 | ||
321 | // memory placement: { 1, 2, 3 } | |
322 | // circular buffer: { 1, 2, 3 } | |
323 | circular_buffer<int> cb1(5); | |
324 | cb1.push_back(1); | |
325 | cb1.push_back(2); | |
326 | cb1.push_back(3); | |
327 | ||
328 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
329 | circular_buffer<int>::iterator it11 = cb1.begin(); | |
330 | circular_buffer<int>::iterator it12 = cb1.begin() + 1; | |
331 | circular_buffer<int>::iterator it13 = cb1.begin() + 2; | |
332 | ||
333 | cb1.rinsert(cb1.begin() + 2, v1.begin(), v1.end()); | |
334 | ||
335 | // memory placement: { 4, 5, 3, 1, 2 } | |
336 | // circular buffer: { 1, 2, 4, 5, 3 } | |
92f5a8d4 TL |
337 | BOOST_TEST(*it11 == 4); |
338 | BOOST_TEST(*it12 == 5); | |
339 | BOOST_TEST(*it13 == 3); | |
340 | BOOST_TEST(cb1[0] == 1); | |
341 | BOOST_TEST(cb1[1] == 2); | |
342 | BOOST_TEST(cb1[2] == 4); | |
343 | BOOST_TEST(cb1[3] == 5); | |
344 | BOOST_TEST(cb1[4] == 3); | |
7c673cae FG |
345 | |
346 | // it14 -> 1, it15 -> 2 | |
347 | circular_buffer<int>::iterator it14 = it11 - 2; | |
348 | circular_buffer<int>::iterator it15 = it11 - 1; | |
349 | ||
350 | cb1.rinsert(cb1.begin() + 4, v2.begin(), v2.end()); | |
351 | ||
352 | // memory placement: { 5, 6, 1, 2, 4 } - 6 inserted only | |
353 | // circular buffer: { 1, 2, 4, 5, 6 } | |
92f5a8d4 TL |
354 | BOOST_TEST(*it11 == 5); |
355 | BOOST_TEST(*it12 == 6); | |
356 | BOOST_TEST(*it13 == 1); | |
357 | BOOST_TEST(*it14 == 2); | |
358 | BOOST_TEST(*it15 == 4); | |
359 | BOOST_TEST(cb1[0] == 1); | |
360 | BOOST_TEST(cb1[1] == 2); | |
361 | BOOST_TEST(cb1[2] == 4); | |
362 | BOOST_TEST(cb1[3] == 5); | |
363 | BOOST_TEST(cb1[4] == 6); | |
7c673cae FG |
364 | |
365 | // memory placement: { 1, 2, 3 } | |
366 | // circular buffer: { 1, 2, 3 } | |
367 | circular_buffer<int> cb2(5); | |
368 | cb2.push_back(1); | |
369 | cb2.push_back(2); | |
370 | cb2.push_back(3); | |
371 | ||
372 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
373 | circular_buffer<int>::iterator it21 = cb2.begin(); | |
374 | circular_buffer<int>::iterator it22 = cb2.begin() + 1; | |
375 | circular_buffer<int>::iterator it23 = cb2.begin() + 2; | |
376 | ||
377 | cb2.rinsert(cb2.begin() + 2, MyInputIterator(v1.begin()), MyInputIterator(v1.end())); | |
378 | ||
379 | // memory placement: { 4, 5, 3, 1, 2 } | |
380 | // circular buffer: { 1, 2, 4, 5, 3 } | |
92f5a8d4 TL |
381 | BOOST_TEST(*it21 == 4); |
382 | BOOST_TEST(*it22 == 5); | |
383 | BOOST_TEST(*it23 == 3); | |
384 | BOOST_TEST(cb2[0] == 1); | |
385 | BOOST_TEST(cb2[1] == 2); | |
386 | BOOST_TEST(cb2[2] == 4); | |
387 | BOOST_TEST(cb2[3] == 5); | |
388 | BOOST_TEST(cb2[4] == 3); | |
7c673cae FG |
389 | |
390 | // it24 -> 1, it25 -> 2 | |
391 | circular_buffer<int>::iterator it24 = it21 - 2; | |
392 | circular_buffer<int>::iterator it25 = it21 - 1; | |
393 | ||
394 | cb2.rinsert(cb2.begin() + 4, MyInputIterator(v2.begin()), MyInputIterator(v2.end())); | |
395 | ||
396 | // memory placement: { 5, 6, 1, 2, 4 } | |
397 | // circular buffer: { 1, 2, 4, 5, 6 } | |
92f5a8d4 TL |
398 | BOOST_TEST(*it21 == 5); |
399 | BOOST_TEST(*it22 == 6); | |
400 | BOOST_TEST(*it23 == 1); | |
401 | BOOST_TEST(*it24 == 2); | |
402 | BOOST_TEST(*it25 == 4); | |
403 | BOOST_TEST(cb2[0] == 1); | |
404 | BOOST_TEST(cb2[1] == 2); | |
405 | BOOST_TEST(cb2[2] == 4); | |
406 | BOOST_TEST(cb2[3] == 5); | |
407 | BOOST_TEST(cb2[4] == 6); | |
7c673cae FG |
408 | } |
409 | ||
410 | void validity_erase_test() { | |
411 | ||
412 | // memory placement: { 4, 5, 1, 2, 3 } | |
413 | // circular buffer: { 1, 2, 3, 4, 5 } | |
414 | circular_buffer<int> cb(5); | |
415 | cb.push_back(-1); | |
416 | cb.push_back(0); | |
417 | cb.push_back(1); | |
418 | cb.push_back(2); | |
419 | cb.push_back(3); | |
420 | cb.push_back(4); | |
421 | cb.push_back(5); | |
422 | ||
423 | // it1 -> 1, it2 -> 2, it3 -> 3, it4 -> 4 | |
424 | circular_buffer<int>::iterator it1 = cb.begin(); | |
425 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
426 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
427 | circular_buffer<int>::iterator it4 = cb.begin() + 3; | |
428 | ||
429 | cb.erase(cb.begin() + 1); | |
430 | ||
431 | // memory placement: { 5, X, 1, 3, 4 } | |
432 | // circular buffer: { 1, 3, 4, 5 } | |
92f5a8d4 TL |
433 | BOOST_TEST(*it1 == 1); |
434 | BOOST_TEST(*it2 == 3); | |
435 | BOOST_TEST(*it3 == 4); | |
436 | BOOST_TEST(*it4 == 5); | |
437 | BOOST_TEST(cb[0] == 1); | |
438 | BOOST_TEST(cb[1] == 3); | |
439 | BOOST_TEST(cb[2] == 4); | |
440 | BOOST_TEST(cb[3] == 5); | |
7c673cae FG |
441 | } |
442 | ||
443 | void validity_erase_range_test() { | |
444 | ||
445 | // memory placement: { 4, 5, 6, 1, 2, 3 } | |
446 | // circular buffer: { 1, 2, 3, 4, 5, 6 } | |
447 | circular_buffer<int> cb(6); | |
448 | cb.push_back(-2); | |
449 | cb.push_back(-1); | |
450 | cb.push_back(0); | |
451 | cb.push_back(1); | |
452 | cb.push_back(2); | |
453 | cb.push_back(3); | |
454 | cb.push_back(4); | |
455 | cb.push_back(5); | |
456 | cb.push_back(6); | |
457 | ||
458 | // it1 -> 1, it2 -> 2, it3 -> 3, it4 -> 4 | |
459 | circular_buffer<int>::iterator it1 = cb.begin(); | |
460 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
461 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
462 | circular_buffer<int>::iterator it4 = cb.begin() + 3; | |
463 | ||
464 | cb.erase(cb.begin() + 2, cb.begin() + 4); | |
465 | ||
466 | // memory placement: { 6, X, X, 1, 2, 5 } | |
467 | // circular buffer: { 1, 2, 5, 6 } | |
92f5a8d4 TL |
468 | BOOST_TEST(*it1 == 1); |
469 | BOOST_TEST(*it2 == 2); | |
470 | BOOST_TEST(*it3 == 5); | |
471 | BOOST_TEST(*it4 == 6); | |
472 | BOOST_TEST(cb[0] == 1); | |
473 | BOOST_TEST(cb[1] == 2); | |
474 | BOOST_TEST(cb[2] == 5); | |
475 | BOOST_TEST(cb[3] == 6); | |
7c673cae FG |
476 | } |
477 | ||
478 | void validity_rerase_test() { | |
479 | ||
480 | // memory placement: { 4, 5, 1, 2, 3 } | |
481 | // circular buffer: { 1, 2, 3, 4, 5 } | |
482 | circular_buffer<int> cb(5); | |
483 | cb.push_back(-1); | |
484 | cb.push_back(0); | |
485 | cb.push_back(1); | |
486 | cb.push_back(2); | |
487 | cb.push_back(3); | |
488 | cb.push_back(4); | |
489 | cb.push_back(5); | |
490 | ||
491 | // it1 -> 2, it2 -> 3, it3 -> 4, it4 -> 5 | |
492 | circular_buffer<int>::iterator it1 = cb.begin() + 1; | |
493 | circular_buffer<int>::iterator it2 = cb.begin() + 2; | |
494 | circular_buffer<int>::iterator it3 = cb.begin() + 3; | |
495 | circular_buffer<int>::iterator it4 = cb.begin() + 4; | |
496 | ||
497 | cb.rerase(cb.begin() + 1); | |
498 | ||
499 | // memory placement: { 4, 5, X, 1, 3 } | |
500 | // circular buffer: { 1, 3, 4, 5 } | |
92f5a8d4 TL |
501 | BOOST_TEST(*it1 == 1); |
502 | BOOST_TEST(*it2 == 3); | |
503 | BOOST_TEST(*it3 == 4); | |
504 | BOOST_TEST(*it4 == 5); | |
505 | BOOST_TEST(cb[0] == 1); | |
506 | BOOST_TEST(cb[1] == 3); | |
507 | BOOST_TEST(cb[2] == 4); | |
508 | BOOST_TEST(cb[3] == 5); | |
7c673cae FG |
509 | } |
510 | ||
511 | void validity_rerase_range_test() { | |
512 | ||
513 | // memory placement: { 4, 5, 6, 1, 2, 3 } | |
514 | // circular buffer: { 1, 2, 3, 4, 5, 6 } | |
515 | circular_buffer<int> cb(6); | |
516 | cb.push_back(-2); | |
517 | cb.push_back(-1); | |
518 | cb.push_back(0); | |
519 | cb.push_back(1); | |
520 | cb.push_back(2); | |
521 | cb.push_back(3); | |
522 | cb.push_back(4); | |
523 | cb.push_back(5); | |
524 | cb.push_back(6); | |
525 | ||
526 | // it1 -> 3, it2 -> 4, it3 -> 5, it4 -> 6 | |
527 | circular_buffer<int>::iterator it1 = cb.begin() + 2; | |
528 | circular_buffer<int>::iterator it2 = cb.begin() + 3; | |
529 | circular_buffer<int>::iterator it3 = cb.begin() + 4; | |
530 | circular_buffer<int>::iterator it4 = cb.begin() + 5; | |
531 | ||
532 | cb.rerase(cb.begin() + 2, cb.begin() + 4); | |
533 | ||
534 | // memory placement: { 2, 5, 6, X, X, 1 } | |
535 | // circular buffer: { 1, 2, 5, 6 } | |
92f5a8d4 TL |
536 | BOOST_TEST(*it1 == 1); |
537 | BOOST_TEST(*it2 == 2); | |
538 | BOOST_TEST(*it3 == 5); | |
539 | BOOST_TEST(*it4 == 6); | |
540 | BOOST_TEST(cb[0] == 1); | |
541 | BOOST_TEST(cb[1] == 2); | |
542 | BOOST_TEST(cb[2] == 5); | |
543 | BOOST_TEST(cb[3] == 6); | |
7c673cae FG |
544 | } |
545 | ||
546 | void validity_linearize_test() { | |
547 | ||
548 | // memory placement: { 3, 1, 2 } | |
549 | // circular buffer: { 1, 2, 3 } | |
550 | circular_buffer<int> cb(3); | |
551 | cb.push_back(0); | |
552 | cb.push_back(1); | |
553 | cb.push_back(2); | |
554 | cb.push_back(3); | |
555 | ||
556 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
557 | circular_buffer<int>::iterator it1 = cb.begin(); | |
558 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
559 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
560 | ||
561 | cb.linearize(); | |
562 | ||
563 | // memory placement: { 1, 2, 3 } | |
564 | // circular buffer: { 1, 2, 3 } | |
92f5a8d4 TL |
565 | BOOST_TEST(*it1 == 2); |
566 | BOOST_TEST(*it2 == 3); | |
567 | BOOST_TEST(*it3 == 1); | |
568 | BOOST_TEST(cb[0] == 1); | |
569 | BOOST_TEST(cb[1] == 2); | |
570 | BOOST_TEST(cb[2] == 3); | |
7c673cae FG |
571 | } |
572 | ||
573 | void validity_swap_test() { | |
574 | ||
575 | // memory placement: { 3, 1, 2 } | |
576 | // circular buffer: { 1, 2, 3 } | |
577 | circular_buffer<int> cb1(3); | |
578 | cb1.push_back(0); | |
579 | cb1.push_back(1); | |
580 | cb1.push_back(2); | |
581 | cb1.push_back(3); | |
582 | ||
583 | // it11 -> 1, it12 -> 2, it13 -> 3 | |
584 | circular_buffer<int>::iterator it11 = cb1.begin(); | |
585 | circular_buffer<int>::iterator it12 = cb1.begin() + 1; | |
586 | circular_buffer<int>::iterator it13 = cb1.begin() + 2; | |
587 | ||
588 | // memory placement: { 4, 5, 6 } | |
589 | // circular buffer: { 4, 5, 6 } | |
590 | circular_buffer<int> cb2(5); | |
591 | cb2.push_back(4); | |
592 | cb2.push_back(5); | |
593 | cb2.push_back(6); | |
594 | ||
595 | // it21 -> 4, it22 -> 5, it23 -> 6 | |
596 | circular_buffer<int>::iterator it21 = cb2.begin(); | |
597 | circular_buffer<int>::iterator it22 = cb2.begin() + 1; | |
598 | circular_buffer<int>::iterator it23 = cb2.begin() + 2; | |
599 | ||
600 | cb1.swap(cb2); | |
601 | ||
602 | // Although iterators refer to the original elements, | |
92f5a8d4 | 603 | // their internal state is inconsistent and no other operation |
7c673cae | 604 | // (except dereferencing) can be invoked on them any more. |
92f5a8d4 TL |
605 | BOOST_TEST(*it11 == 1); |
606 | BOOST_TEST(*it12 == 2); | |
607 | BOOST_TEST(*it13 == 3); | |
608 | BOOST_TEST(*it21 == 4); | |
609 | BOOST_TEST(*it22 == 5); | |
610 | BOOST_TEST(*it23 == 6); | |
611 | BOOST_TEST(cb1[0] == 4); | |
612 | BOOST_TEST(cb1[1] == 5); | |
613 | BOOST_TEST(cb1[2] == 6); | |
614 | BOOST_TEST(cb2[0] == 1); | |
615 | BOOST_TEST(cb2[1] == 2); | |
616 | BOOST_TEST(cb2[2] == 3); | |
7c673cae FG |
617 | } |
618 | ||
619 | void validity_push_back_test() { | |
620 | ||
621 | // memory placement: { 3, 1, 2 } | |
622 | // circular buffer: { 1, 2, 3 } | |
623 | circular_buffer<int> cb(3); | |
624 | cb.push_back(0); | |
625 | cb.push_back(1); | |
626 | cb.push_back(2); | |
627 | cb.push_back(3); | |
628 | ||
629 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
630 | circular_buffer<int>::iterator it1 = cb.begin(); | |
631 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
632 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
633 | ||
634 | cb.push_back(4); | |
635 | ||
636 | // memory placement: { 3, 4, 2 } | |
637 | // circular buffer: { 2, 3, 4 } | |
92f5a8d4 TL |
638 | BOOST_TEST(*it1 == 4); |
639 | BOOST_TEST(*it2 == 2); | |
640 | BOOST_TEST(*it3 == 3); | |
641 | BOOST_TEST(cb[0] == 2); | |
642 | BOOST_TEST(cb[1] == 3); | |
643 | BOOST_TEST(cb[2] == 4); | |
7c673cae FG |
644 | } |
645 | ||
646 | void validity_push_front_test() { | |
647 | ||
648 | // memory placement: { 3, 1, 2 } | |
649 | // circular buffer: { 1, 2, 3 } | |
650 | circular_buffer<int> cb(3); | |
651 | cb.push_back(0); | |
652 | cb.push_back(1); | |
653 | cb.push_back(2); | |
654 | cb.push_back(3); | |
655 | ||
656 | // it1 -> 1, it2 -> 2, it3 -> 3 | |
657 | circular_buffer<int>::iterator it1 = cb.begin(); | |
658 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
659 | circular_buffer<int>::iterator it3 = cb.begin() + 2; | |
660 | ||
661 | cb.push_front(4); | |
662 | ||
663 | // memory placement: { 4, 1, 2 } | |
664 | // circular buffer: { 4, 1, 2 } | |
92f5a8d4 TL |
665 | BOOST_TEST(*it1 == 1); |
666 | BOOST_TEST(*it2 == 2); | |
667 | BOOST_TEST(*it3 == 4); | |
668 | BOOST_TEST(cb[0] == 4); | |
669 | BOOST_TEST(cb[1] == 1); | |
670 | BOOST_TEST(cb[2] == 2); | |
7c673cae FG |
671 | } |
672 | ||
673 | void validity_pop_back_test() { | |
674 | ||
675 | // memory placement: { 3, 1, 2 } | |
676 | // circular buffer: { 1, 2, 3 } | |
677 | circular_buffer<int> cb(3); | |
678 | cb.push_back(0); | |
679 | cb.push_back(1); | |
680 | cb.push_back(2); | |
681 | cb.push_back(3); | |
682 | ||
683 | // it1 -> 1, it2 -> 2 | |
684 | circular_buffer<int>::iterator it1 = cb.begin(); | |
685 | circular_buffer<int>::iterator it2 = cb.begin() + 1; | |
686 | ||
687 | cb.pop_back(); | |
688 | ||
689 | // memory placement: { X, 1, 2 } | |
690 | // circular buffer: { 1, 2 } | |
92f5a8d4 TL |
691 | BOOST_TEST(*it1 == 1); |
692 | BOOST_TEST(*it2 == 2); | |
693 | BOOST_TEST(cb[0] == 1); | |
694 | BOOST_TEST(cb[1] == 2); | |
7c673cae FG |
695 | } |
696 | ||
697 | void validity_pop_front_test() { | |
698 | ||
699 | // memory placement: { 3, 1, 2 } | |
700 | // circular buffer: { 1, 2, 3 } | |
701 | circular_buffer<int> cb(3); | |
702 | cb.push_back(0); | |
703 | cb.push_back(1); | |
704 | cb.push_back(2); | |
705 | cb.push_back(3); | |
706 | ||
707 | // it1 -> 2, it2 -> 3 | |
708 | circular_buffer<int>::iterator it1 = cb.begin() + 1; | |
709 | circular_buffer<int>::iterator it2 = cb.begin() + 2; | |
710 | ||
711 | cb.pop_front(); | |
712 | ||
713 | // memory placement: { 3, X, 2 } | |
714 | // circular buffer: { 2, 3 } | |
92f5a8d4 TL |
715 | BOOST_TEST(*it1 == 2); |
716 | BOOST_TEST(*it2 == 3); | |
717 | BOOST_TEST(cb[0] == 2); | |
718 | BOOST_TEST(cb[1] == 3); | |
7c673cae FG |
719 | } |
720 | ||
721 | // test main | |
92f5a8d4 TL |
722 | int main() |
723 | { | |
724 | validity_example_test(); | |
725 | validity_insert_test(); | |
726 | validity_insert_n_test(); | |
727 | validity_insert_range_test(); | |
728 | validity_rinsert_test(); | |
729 | validity_rinsert_n_test(); | |
730 | validity_rinsert_range_test(); | |
731 | validity_erase_test(); | |
732 | validity_erase_range_test(); | |
733 | validity_rerase_test(); | |
734 | validity_rerase_range_test(); | |
735 | validity_linearize_test(); | |
736 | validity_swap_test(); | |
737 | validity_push_back_test(); | |
738 | validity_push_front_test(); | |
739 | validity_pop_back_test(); | |
740 | validity_pop_front_test(); | |
741 | return boost::report_errors(); | |
7c673cae | 742 | } |