]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Common tests for the circular buffer and its adaptor. |
2 | ||
3 | // Copyright (c) 2003-2008 Jan Gaspar | |
4 | // Copyright (c) 2013 Antony Polukhin | |
5 | // Copyright (c) 2014 Glen Fernandes // C++11 allocator model support. | |
6 | ||
7 | // Use, modification, and distribution is subject to the Boost Software | |
8 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
9 | // http://www.boost.org/LICENSE_1_0.txt) | |
10 | ||
11 | #include <boost/type_traits/is_nothrow_move_constructible.hpp> | |
12 | #include <boost/type_traits/is_nothrow_move_assignable.hpp> | |
13 | #include <boost/type_traits/has_nothrow_constructor.hpp> | |
14 | ||
15 | template <class Alloc> | |
16 | void generic_test(CB_CONTAINER<MyInteger, Alloc>& cb) { | |
17 | ||
18 | vector<int> v; | |
19 | v.push_back(11); | |
20 | v.push_back(12); | |
21 | v.push_back(13); | |
22 | v.push_back(14); | |
23 | v.push_back(15); | |
24 | v.push_back(16); | |
25 | v.push_back(17); | |
26 | ||
27 | if (cb.capacity() == 0) { | |
28 | ||
29 | cb.insert(cb.begin(), 1); | |
30 | cb.insert(cb.begin(), v.begin(), v.end()); | |
31 | cb.rinsert(cb.end(), 2); | |
32 | cb.rinsert(cb.end(), v.begin(), v.end()); | |
33 | cb.push_back(3); | |
34 | cb.push_front(4); | |
35 | cb.linearize(); | |
36 | ||
37 | BOOST_CHECK(cb.empty()); | |
38 | BOOST_CHECK(cb.full()); | |
39 | ||
40 | } else { | |
41 | ||
42 | cb.insert(cb.end(), 1); | |
43 | BOOST_CHECK(!cb.empty()); | |
44 | BOOST_CHECK(cb[cb.size() - 1] == 1); | |
45 | ||
46 | size_t size = cb.size(); | |
47 | cb.rerase(cb.end() - 1, cb.end()); | |
48 | BOOST_CHECK(size == cb.size() + 1); | |
49 | ||
50 | cb.insert(cb.end(), v.begin(), v.end()); | |
51 | BOOST_CHECK(!cb.empty()); | |
52 | BOOST_CHECK(cb[cb.size() - 1] == 17); | |
53 | ||
54 | size = cb.size(); | |
55 | cb.erase(cb.end() - 1, cb.end()); | |
56 | BOOST_CHECK(size == cb.size() + 1); | |
57 | ||
58 | size = cb.size(); | |
59 | cb.rinsert(cb.begin(), 2); | |
60 | BOOST_CHECK(size + 1 == cb.size()); | |
61 | BOOST_CHECK(cb[0] == 2); | |
62 | ||
63 | size = cb.size(); | |
64 | cb.erase(cb.begin()); | |
65 | BOOST_CHECK(size == cb.size() + 1); | |
66 | ||
67 | cb.rinsert(cb.begin(), v.begin(), v.end()); | |
68 | BOOST_CHECK(!cb.empty()); | |
69 | BOOST_CHECK(cb[0] == 11); | |
70 | ||
71 | size = cb.size(); | |
72 | cb.pop_front(); | |
73 | BOOST_CHECK(size == cb.size() + 1); | |
74 | ||
75 | cb.push_back(3); | |
76 | BOOST_CHECK(!cb.empty()); | |
77 | BOOST_CHECK(cb[cb.size() - 1] == 3); | |
78 | ||
79 | size = cb.size(); | |
80 | cb.pop_back(); | |
81 | BOOST_CHECK(size == cb.size() + 1); | |
82 | ||
83 | cb.push_front(4); | |
84 | BOOST_CHECK(!cb.empty()); | |
85 | BOOST_CHECK(cb[0] == 4); | |
86 | ||
87 | cb.linearize(); | |
88 | BOOST_CHECK(!cb.empty()); | |
89 | BOOST_CHECK(cb[0] == 4); | |
90 | ||
91 | size = cb.size(); | |
92 | cb.rerase(cb.begin()); | |
93 | BOOST_CHECK(size == cb.size() + 1); | |
94 | } | |
95 | } | |
96 | ||
97 | void basic_test() { | |
98 | ||
99 | vector<int> v; | |
100 | v.push_back(1); | |
101 | v.push_back(2); | |
102 | v.push_back(3); | |
103 | v.push_back(4); | |
104 | v.push_back(5); | |
105 | v.push_back(6); | |
106 | v.push_back(7); | |
107 | CB_CONTAINER<MyInteger> cb1(3, v.begin(), v.end()); | |
108 | CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end()); | |
109 | CB_CONTAINER<MyInteger> cb3(7, v.begin(), v.end()); | |
110 | ||
111 | BOOST_CHECK(cb1.full()); | |
112 | BOOST_CHECK(cb1.capacity() == 3); | |
113 | BOOST_CHECK(cb1.size() == 3); | |
114 | BOOST_CHECK(cb1[0] == 5); | |
115 | BOOST_CHECK(cb1[2] == 7); | |
116 | BOOST_CHECK(!cb2.full()); | |
117 | BOOST_CHECK(cb2[2] == 3); | |
118 | BOOST_CHECK(cb3.full()); | |
119 | BOOST_CHECK(cb3[0] == 1); | |
120 | BOOST_CHECK(cb3[6] == 7); | |
121 | ||
122 | generic_test(cb1); | |
123 | generic_test(cb2); | |
124 | generic_test(cb3); | |
125 | } | |
126 | ||
127 | void constructor_and_element_access_test() { | |
128 | ||
129 | CB_CONTAINER<int> cb(5, 3); | |
130 | cb[1] = 10; | |
131 | ||
132 | BOOST_CHECK(cb.full()); | |
133 | BOOST_CHECK(cb[1] == 10); | |
134 | BOOST_CHECK(cb[4] == 3); | |
135 | } | |
136 | ||
137 | void size_test() { | |
138 | ||
139 | CB_CONTAINER<MyInteger> cb1(3); | |
140 | cb1.push_back(1); | |
141 | cb1.push_back(2); | |
142 | cb1.push_back(3); | |
143 | cb1.push_back(4); | |
144 | CB_CONTAINER<MyInteger> cb2(5); | |
145 | ||
146 | BOOST_CHECK(cb1.size() == 3); | |
147 | BOOST_CHECK(cb2.size() == 0); | |
148 | BOOST_CHECK(cb1.max_size() == cb2.max_size()); | |
149 | ||
150 | generic_test(cb1); | |
151 | generic_test(cb2); | |
152 | } | |
153 | ||
154 | template<class T> | |
155 | class my_allocator { | |
156 | typedef std::allocator<T> base_t; | |
157 | base_t base_; | |
158 | public: | |
159 | typedef T value_type; | |
160 | ||
161 | ||
162 | typedef value_type& reference; | |
163 | typedef const value_type& const_reference; | |
164 | typedef typename base_t::size_type size_type; | |
165 | typedef typename base_t::difference_type difference_type; | |
166 | ||
167 | private: | |
168 | template<class U> | |
169 | struct const_pointer_; | |
170 | ||
171 | template<class U> | |
172 | struct pointer_ { | |
173 | pointer_(){} | |
174 | pointer_(void* p) : hidden_ptr_((U*)p) {} | |
175 | difference_type operator-(const const_pointer_<U>& rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; } | |
176 | difference_type operator-(pointer_ rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; } | |
177 | pointer_ operator-(size_type rhs) const { return hidden_ptr_ - rhs; } | |
178 | bool operator == (pointer_ rhs) const { return hidden_ptr_ == rhs.hidden_ptr_; } | |
179 | bool operator != (pointer_ rhs) const { return hidden_ptr_ != rhs.hidden_ptr_; } | |
180 | bool operator < (pointer_ rhs) const { return hidden_ptr_ < rhs.hidden_ptr_; } | |
181 | bool operator >= (pointer_ rhs) const { return hidden_ptr_ >= rhs.hidden_ptr_; } | |
182 | pointer_& operator++() { ++hidden_ptr_; return *this; } | |
183 | pointer_& operator--() { --hidden_ptr_; return *this; } | |
184 | pointer_& operator+=(size_type s) { hidden_ptr_ += s; return *this; } | |
185 | pointer_ operator+(size_type s) const { return hidden_ptr_ + s; } | |
186 | pointer_ operator++(int) { pointer_ p = *this; ++hidden_ptr_; return p; } | |
187 | pointer_ operator--(int) { pointer_ p = *this; --hidden_ptr_; return p; } | |
188 | U& operator*() const { return *hidden_ptr_; } | |
189 | ||
190 | U* hidden_ptr_; | |
191 | }; | |
192 | ||
193 | template<class U> | |
194 | struct const_pointer_ { | |
195 | const_pointer_(){} | |
196 | const_pointer_(pointer_<U> p) : hidden_ptr_(p.hidden_ptr_) {} | |
197 | const_pointer_(const void* p) : hidden_ptr_((const U*)p) {} | |
198 | difference_type operator-(pointer_<U> rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; } | |
199 | difference_type operator-(const_pointer_ rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; } | |
200 | const_pointer_ operator-(size_type rhs) const { return hidden_ptr_ - rhs; } | |
201 | bool operator == (const_pointer_ rhs) const { return hidden_ptr_ == rhs.hidden_ptr_; } | |
202 | bool operator != (const_pointer_ rhs) const { return hidden_ptr_ != rhs.hidden_ptr_; } | |
203 | bool operator < (const_pointer_ rhs) const { return hidden_ptr_ < rhs.hidden_ptr_; } | |
204 | bool operator >= (const_pointer_ rhs) const { return hidden_ptr_ >= rhs.hidden_ptr_; } | |
205 | const_pointer_& operator++() { ++hidden_ptr_; return *this; } | |
206 | const_pointer_& operator--() { --hidden_ptr_; return *this; } | |
207 | const_pointer_& operator+=(size_type s) { hidden_ptr_ += s; return hidden_ptr_; } | |
208 | const_pointer_ operator+(size_type s) const { return hidden_ptr_ + s; } | |
209 | const_pointer_ operator++(int) { const_pointer_ p = *this; ++hidden_ptr_; return p; } | |
210 | const_pointer_ operator--(int) { const_pointer_ p = *this; --hidden_ptr_; return p; } | |
211 | const U& operator*() const { return *hidden_ptr_; } | |
212 | ||
213 | const U* hidden_ptr_; | |
214 | }; | |
215 | ||
216 | public: | |
217 | typedef pointer_<T> pointer; | |
218 | typedef const_pointer_<T> const_pointer; | |
219 | ||
220 | template<class T2> | |
221 | struct rebind | |
222 | { | |
223 | typedef my_allocator<T2> other; | |
224 | }; | |
225 | ||
226 | size_type max_size() const | |
227 | { return base_.max_size(); } | |
228 | ||
229 | pointer allocate(size_type count, const void* hint = 0) { | |
230 | return pointer(base_.allocate(count, hint)); | |
231 | } | |
232 | ||
233 | void deallocate(const pointer &ptr, size_type s) | |
234 | { base_.deallocate(ptr.hidden_ptr_, s); } | |
235 | ||
236 | template<class P> | |
237 | void construct(const pointer &ptr, BOOST_FWD_REF(P) p) | |
238 | { ::new(ptr.hidden_ptr_) value_type(::boost::forward<P>(p)); } | |
239 | ||
240 | void destroy(const pointer &ptr) | |
241 | { (*ptr.hidden_ptr_).~value_type(); } | |
242 | ||
243 | }; | |
244 | ||
245 | void allocator_test() { | |
246 | ||
247 | CB_CONTAINER<MyInteger> cb1(10, 0); | |
248 | const CB_CONTAINER<MyInteger> cb2(10, 0); | |
249 | CB_CONTAINER<MyInteger>::allocator_type& alloc_ref = cb1.get_allocator(); | |
250 | CB_CONTAINER<MyInteger>::allocator_type alloc = cb2.get_allocator(); | |
251 | alloc_ref.max_size(); | |
252 | alloc.max_size(); | |
253 | ||
254 | generic_test(cb1); | |
255 | ||
256 | ||
257 | CB_CONTAINER<MyInteger, my_allocator<MyInteger> > cb_a(10, 0); | |
258 | generic_test(cb_a); | |
259 | } | |
260 | ||
261 | #if !defined(BOOST_NO_CXX11_ALLOCATOR) | |
262 | template<class T> | |
263 | class cxx11_allocator { | |
264 | public: | |
265 | typedef T value_type; | |
266 | ||
267 | cxx11_allocator() { | |
268 | } | |
269 | ||
270 | template<class U> | |
271 | cxx11_allocator(const cxx11_allocator<U> &) { | |
272 | } | |
273 | ||
274 | T* allocate(std::size_t n) { | |
275 | return static_cast<T*>(::operator new(n * sizeof(T))); | |
276 | } | |
277 | ||
278 | void deallocate(T * p, std::size_t n) { | |
279 | ::operator delete( p ); | |
280 | } | |
281 | }; | |
282 | ||
283 | void cxx11_allocator_test() { | |
284 | CB_CONTAINER<MyInteger, cxx11_allocator<MyInteger> > cb(10, 0); | |
285 | generic_test(cb); | |
286 | } | |
287 | #endif | |
288 | ||
289 | void begin_and_end_test() { | |
290 | ||
291 | vector<int> v; | |
292 | v.push_back(11); | |
293 | v.push_back(12); | |
294 | v.push_back(13); | |
295 | ||
296 | CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.end()); | |
297 | const CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end()); | |
298 | ||
299 | CB_CONTAINER<MyInteger> cb3(10); | |
300 | cb3.push_back(1); | |
301 | cb3.push_back(2); | |
302 | cb3.insert(cb3.begin(), 3); | |
303 | int i = 0; | |
304 | CB_CONTAINER<MyInteger>::const_iterator it = cb3.begin(); | |
305 | for (; it != cb3.end(); it++) { | |
306 | i += *it; | |
307 | } | |
308 | CB_CONTAINER<MyInteger> cb4(20); | |
309 | const CB_CONTAINER<MyInteger> cb5(20); | |
310 | ||
311 | BOOST_CHECK(*cb1.begin() == 11); | |
312 | BOOST_CHECK(*cb2.begin() == 11); | |
313 | BOOST_CHECK(i == 6); | |
314 | BOOST_CHECK(cb4.begin() == cb4.end()); | |
315 | BOOST_CHECK(cb5.begin() == cb5.end()); | |
316 | ||
317 | generic_test(cb1); | |
318 | generic_test(cb3); | |
319 | generic_test(cb4); | |
320 | } | |
321 | ||
322 | void rbegin_and_rend_test() { | |
323 | ||
324 | vector<int> v; | |
325 | v.push_back(11); | |
326 | v.push_back(12); | |
327 | v.push_back(13); | |
328 | ||
329 | CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.end()); | |
330 | const CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end()); | |
331 | ||
332 | CB_CONTAINER<MyInteger> cb3(3); | |
333 | cb3.push_back(1); | |
334 | cb3.push_back(2); | |
335 | cb3.insert(cb3.begin(), 3); | |
336 | cb3.push_back(1); | |
337 | int i = 0; | |
338 | CB_CONTAINER<MyInteger>::reverse_iterator it = cb3.rbegin(); | |
339 | for (; it != cb3.rend(); it++) { | |
340 | i += *it; | |
341 | } | |
342 | CB_CONTAINER<MyInteger> cb4(20); | |
343 | const CB_CONTAINER<MyInteger> cb5(20); | |
344 | ||
345 | BOOST_CHECK(*cb1.rbegin() == 13); | |
346 | BOOST_CHECK(*cb2.rbegin() == 13); | |
347 | BOOST_CHECK(i == 4); | |
348 | BOOST_CHECK(cb4.rbegin() == cb4.rend()); | |
349 | BOOST_CHECK(cb5.rbegin() == cb5.rend()); | |
350 | ||
351 | generic_test(cb1); | |
352 | generic_test(cb3); | |
353 | generic_test(cb4); | |
354 | } | |
355 | ||
356 | void element_access_and_insert_test() { | |
357 | ||
358 | CB_CONTAINER<MyInteger> cb(3); | |
359 | cb.push_back(1); | |
360 | cb.push_back(2); | |
361 | cb.insert(cb.begin(), 3); | |
362 | cb.push_back(4); | |
363 | const CB_CONTAINER<MyInteger> ccb = cb; | |
364 | ||
365 | BOOST_CHECK(cb[0] == 1); | |
366 | BOOST_CHECK(cb[1] == 2); | |
367 | BOOST_CHECK(cb[2] == 4); | |
368 | BOOST_CHECK(ccb[2] == 4); | |
369 | ||
370 | generic_test(cb); | |
371 | } | |
372 | ||
373 | void at_test() { | |
374 | ||
375 | #if !defined(BOOST_NO_EXCEPTIONS) | |
376 | ||
377 | CB_CONTAINER<MyInteger> cb(3); | |
378 | cb.push_back(1); | |
379 | ||
380 | try { | |
381 | BOOST_CHECK(cb.at(0) == 1); | |
382 | } | |
383 | catch (out_of_range&) { | |
384 | BOOST_ERROR("An unexpected exception has been thrown!"); | |
385 | } | |
386 | ||
387 | BOOST_CHECK_THROW(cb.at(2), out_of_range); | |
388 | ||
389 | generic_test(cb); | |
390 | ||
391 | #endif // #if !defined(BOOST_NO_EXCEPTIONS) | |
392 | } | |
393 | ||
394 | void front_and_back_test() { | |
395 | ||
396 | CB_CONTAINER<MyInteger> cb(1); | |
397 | cb.push_back(2); | |
398 | cb.push_back(3); | |
399 | ||
400 | BOOST_CHECK(cb.front() == cb.back()); | |
401 | BOOST_CHECK(cb.back() == 3); | |
402 | ||
403 | generic_test(cb); | |
404 | } | |
405 | ||
406 | void linearize_test() { | |
407 | ||
408 | vector<int> v; | |
409 | v.push_back(1); | |
410 | v.push_back(2); | |
411 | v.push_back(3); | |
412 | v.push_back(4); | |
413 | v.push_back(5); | |
414 | v.push_back(6); | |
415 | v.push_back(7); | |
416 | v.push_back(8); | |
417 | v.push_back(9); | |
418 | v.push_back(10); | |
419 | v.push_back(11); | |
420 | v.push_back(12); | |
421 | CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.begin() + 10); | |
422 | cb1.push_back(11); | |
423 | cb1.push_back(12); | |
424 | cb1.push_back(13); | |
425 | CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.begin() + 10); | |
426 | cb2.push_back(11); | |
427 | cb2.push_back(12); | |
428 | cb2.push_back(13); | |
429 | cb2.push_back(14); | |
430 | cb2.push_back(15); | |
431 | cb2.push_back(16); | |
432 | cb2.push_back(17); | |
433 | CB_CONTAINER<MyInteger> cb3(10, v.begin(), v.begin() + 10); | |
434 | cb3.push_back(11); | |
435 | cb3.push_back(12); | |
436 | cb3.push_back(13); | |
437 | cb3.pop_front(); | |
438 | cb3.pop_front(); | |
439 | CB_CONTAINER<MyInteger> cb4(5); | |
440 | CB_CONTAINER<MyInteger> cb5(12, v.begin(), v.end()); | |
441 | cb5.push_back(13); | |
442 | cb5.push_back(14); | |
443 | cb5.push_back(15); | |
444 | cb5.pop_front(); | |
445 | cb5.pop_front(); | |
446 | cb5.pop_front(); | |
447 | cb5.pop_front(); | |
448 | cb5.pop_front(); | |
449 | cb5.pop_front(); | |
450 | CB_CONTAINER<MyInteger> cb6(6); | |
451 | cb6.push_back(-2); | |
452 | cb6.push_back(-1); | |
453 | cb6.push_back(0); | |
454 | cb6.push_back(1); | |
455 | cb6.push_back(2); | |
456 | cb6.push_back(3); | |
457 | cb6.push_back(4); | |
458 | cb6.push_back(5); | |
459 | cb6.push_back(6); | |
460 | cb6.pop_back(); | |
461 | CB_CONTAINER<MyInteger> cb7(6); | |
462 | cb7.push_back(0); | |
463 | cb7.push_back(1); | |
464 | cb7.push_back(2); | |
465 | cb7.push_back(3); | |
466 | cb7.push_back(4); | |
467 | ||
468 | BOOST_CHECK(!cb1.is_linearized()); | |
469 | BOOST_CHECK(*cb1.linearize() == 4); | |
470 | BOOST_CHECK(cb1.is_linearized()); | |
471 | BOOST_CHECK(cb1.linearize() == cb1.array_one().first); | |
472 | BOOST_CHECK(&cb1[0] < &cb1[1] | |
473 | && &cb1[1] < &cb1[2] | |
474 | && &cb1[2] < &cb1[3] | |
475 | && &cb1[3] < &cb1[4] | |
476 | && &cb1[4] < &cb1[5] | |
477 | && &cb1[5] < &cb1[6] | |
478 | && &cb1[6] < &cb1[7] | |
479 | && &cb1[7] < &cb1[8] | |
480 | && &cb1[8] < &cb1[9]); | |
481 | BOOST_CHECK(*(cb1.linearize() + 1) == 5); | |
482 | BOOST_CHECK(*(cb1.linearize() + 2) == 6); | |
483 | BOOST_CHECK(*(cb1.linearize() + 3) == 7); | |
484 | BOOST_CHECK(*(cb1.linearize() + 4) == 8); | |
485 | BOOST_CHECK(*(cb1.linearize() + 5) == 9); | |
486 | BOOST_CHECK(*(cb1.linearize() + 6) == 10); | |
487 | BOOST_CHECK(*(cb1.linearize() + 7) == 11); | |
488 | BOOST_CHECK(*(cb1.linearize() + 8) == 12); | |
489 | BOOST_CHECK(*(cb1.linearize() + 9) == 13); | |
490 | BOOST_CHECK(!cb2.is_linearized()); | |
491 | BOOST_CHECK(*cb2.linearize() == 8); | |
492 | BOOST_CHECK(cb2.is_linearized()); | |
493 | BOOST_CHECK(&cb2[0] < &cb2[1] | |
494 | && &cb2[1] < &cb2[2] | |
495 | && &cb2[2] < &cb2[3] | |
496 | && &cb2[3] < &cb2[4] | |
497 | && &cb2[4] < &cb2[5] | |
498 | && &cb2[5] < &cb2[6] | |
499 | && &cb2[6] < &cb2[7] | |
500 | && &cb2[7] < &cb2[8] | |
501 | && &cb2[8] < &cb2[9]); | |
502 | BOOST_CHECK(*(cb2.linearize() + 1) == 9); | |
503 | BOOST_CHECK(*(cb2.linearize() + 2) == 10); | |
504 | BOOST_CHECK(*(cb2.linearize() + 3) == 11); | |
505 | BOOST_CHECK(*(cb2.linearize() + 4) == 12); | |
506 | BOOST_CHECK(*(cb2.linearize() + 5) == 13); | |
507 | BOOST_CHECK(*(cb2.linearize() + 6) == 14); | |
508 | BOOST_CHECK(*(cb2.linearize() + 7) == 15); | |
509 | BOOST_CHECK(*(cb2.linearize() + 8) == 16); | |
510 | BOOST_CHECK(*(cb2.linearize() + 9) == 17); | |
511 | BOOST_CHECK(cb2.is_linearized()); | |
512 | BOOST_CHECK(*cb3.linearize() == 6); | |
513 | BOOST_CHECK(cb3.is_linearized()); | |
514 | BOOST_CHECK(&cb3[0] < &cb3[1] | |
515 | && &cb3[1] < &cb3[2] | |
516 | && &cb3[2] < &cb3[3] | |
517 | && &cb3[3] < &cb3[4] | |
518 | && &cb3[4] < &cb3[5] | |
519 | && &cb3[5] < &cb3[6] | |
520 | && &cb3[6] < &cb3[7]); | |
521 | BOOST_CHECK(*(cb3.linearize() + 1) == 7); | |
522 | BOOST_CHECK(*(cb3.linearize() + 2) == 8); | |
523 | BOOST_CHECK(*(cb3.linearize() + 3) == 9); | |
524 | BOOST_CHECK(*(cb3.linearize() + 4) == 10); | |
525 | BOOST_CHECK(*(cb3.linearize() + 5) == 11); | |
526 | BOOST_CHECK(*(cb3.linearize() + 6) == 12); | |
527 | BOOST_CHECK(*(cb3.linearize() + 7) == 13); | |
528 | BOOST_CHECK(cb4.linearize() == 0); | |
529 | BOOST_CHECK(cb4.is_linearized()); | |
530 | BOOST_CHECK(*cb5.linearize() == 10); | |
531 | BOOST_CHECK(cb5.is_linearized()); | |
532 | BOOST_CHECK(&cb5[0] < &cb5[1] | |
533 | && &cb5[1] < &cb5[2] | |
534 | && &cb5[2] < &cb5[3] | |
535 | && &cb5[3] < &cb5[4] | |
536 | && &cb5[4] < &cb5[5]); | |
537 | BOOST_CHECK(*(cb5.linearize() + 1) == 11); | |
538 | BOOST_CHECK(*(cb5.linearize() + 2) == 12); | |
539 | BOOST_CHECK(*(cb5.linearize() + 3) == 13); | |
540 | BOOST_CHECK(*(cb5.linearize() + 4) == 14); | |
541 | BOOST_CHECK(*(cb5.linearize() + 5) == 15); | |
542 | BOOST_CHECK(*cb6.linearize() == 1); | |
543 | BOOST_CHECK(cb6.is_linearized()); | |
544 | BOOST_CHECK(&cb6[0] < &cb6[1] | |
545 | && &cb6[1] < &cb6[2] | |
546 | && &cb6[2] < &cb6[3] | |
547 | && &cb6[3] < &cb6[4]); | |
548 | BOOST_CHECK(*(cb6.linearize() + 1) == 2); | |
549 | BOOST_CHECK(*(cb6.linearize() + 2) == 3); | |
550 | BOOST_CHECK(*(cb6.linearize() + 3) == 4); | |
551 | BOOST_CHECK(*(cb6.linearize() + 4) == 5); | |
552 | BOOST_CHECK(cb7.is_linearized()); | |
553 | ||
554 | generic_test(cb1); | |
555 | generic_test(cb2); | |
556 | generic_test(cb3); | |
557 | generic_test(cb4); | |
558 | generic_test(cb5); | |
559 | generic_test(cb6); | |
560 | generic_test(cb7); | |
561 | } | |
562 | ||
563 | void array_range_test() { | |
564 | ||
565 | CB_CONTAINER<MyInteger> cb(7); | |
566 | CB_CONTAINER<MyInteger>::array_range a1 = cb.array_one(); | |
567 | CB_CONTAINER<MyInteger>::array_range a2 = cb.array_two(); | |
568 | CB_CONTAINER<MyInteger>::const_array_range ca1 = cb.array_one(); | |
569 | CB_CONTAINER<MyInteger>::const_array_range ca2 = cb.array_two(); | |
570 | ||
571 | BOOST_CHECK(a1.second == 0); | |
572 | BOOST_CHECK(a2.second == 0); | |
573 | BOOST_CHECK(ca1.second == 0); | |
574 | BOOST_CHECK(ca2.second == 0); | |
575 | ||
576 | cb.push_back(1); | |
577 | cb.push_back(2); | |
578 | cb.push_back(3); | |
579 | a1 = cb.array_one(); | |
580 | a2 = cb.array_two(); | |
581 | ca1 = cb.array_one(); | |
582 | ca2 = cb.array_two(); | |
583 | ||
584 | BOOST_CHECK(a1.first[0] == 1); | |
585 | BOOST_CHECK(a1.first[2] == 3); | |
586 | BOOST_CHECK(ca1.first[0] == 1); | |
587 | BOOST_CHECK(ca1.first[2] == 3); | |
588 | BOOST_CHECK(a1.second == 3); | |
589 | BOOST_CHECK(a2.second == 0); | |
590 | BOOST_CHECK(ca1.second == 3); | |
591 | BOOST_CHECK(ca2.second == 0); | |
592 | ||
593 | cb.push_back(4); | |
594 | cb.push_back(5); | |
595 | cb.push_back(6); | |
596 | cb.push_back(7); | |
597 | cb.push_back(8); | |
598 | cb.push_back(9); | |
599 | cb.push_back(10); | |
600 | a1 = cb.array_one(); | |
601 | a2 = cb.array_two(); | |
602 | ca1 = cb.array_one(); | |
603 | ca2 = cb.array_two(); | |
604 | ||
605 | BOOST_CHECK(a1.first[0] == 4); | |
606 | BOOST_CHECK(a1.first[3] == 7); | |
607 | BOOST_CHECK(a2.first[0] == 8); | |
608 | BOOST_CHECK(a2.first[2] == 10); | |
609 | BOOST_CHECK(ca1.first[0] == 4); | |
610 | BOOST_CHECK(ca1.first[3] == 7); | |
611 | BOOST_CHECK(ca2.first[0] == 8); | |
612 | BOOST_CHECK(ca2.first[2] == 10); | |
613 | BOOST_CHECK(a1.second == 4); | |
614 | BOOST_CHECK(a2.second == 3); | |
615 | BOOST_CHECK(ca1.second == 4); | |
616 | BOOST_CHECK(ca2.second == 3); | |
617 | ||
618 | cb.pop_front(); | |
619 | cb.pop_back(); | |
620 | a1 = cb.array_one(); | |
621 | a2 = cb.array_two(); | |
622 | ca1 = cb.array_one(); | |
623 | ca2 = cb.array_two(); | |
624 | ||
625 | BOOST_CHECK(a1.first[0] == 5); | |
626 | BOOST_CHECK(a1.first[2] == 7); | |
627 | BOOST_CHECK(a2.first[0] == 8); | |
628 | BOOST_CHECK(a2.first[1] == 9); | |
629 | BOOST_CHECK(ca1.first[0] == 5); | |
630 | BOOST_CHECK(ca1.first[2] == 7); | |
631 | BOOST_CHECK(ca2.first[0] == 8); | |
632 | BOOST_CHECK(ca2.first[1] == 9); | |
633 | BOOST_CHECK(a1.second == 3); | |
634 | BOOST_CHECK(a2.second == 2); | |
635 | BOOST_CHECK(ca1.second == 3); | |
636 | BOOST_CHECK(ca2.second == 2); | |
637 | ||
638 | cb.pop_back(); | |
639 | cb.pop_back(); | |
640 | cb.pop_back(); | |
641 | a1 = cb.array_one(); | |
642 | a2 = cb.array_two(); | |
643 | ca1 = cb.array_one(); | |
644 | ca2 = cb.array_two(); | |
645 | ||
646 | BOOST_CHECK(a1.first[0] == 5); | |
647 | BOOST_CHECK(a1.first[1] == 6); | |
648 | BOOST_CHECK(ca1.first[0] == 5); | |
649 | BOOST_CHECK(ca1.first[1] == 6); | |
650 | BOOST_CHECK(a1.second == 2); | |
651 | BOOST_CHECK(a2.second == 0); | |
652 | BOOST_CHECK(ca1.second == 2); | |
653 | BOOST_CHECK(ca2.second == 0); | |
654 | ||
655 | CB_CONTAINER<MyInteger> cb0(0); | |
656 | a1 = cb0.array_one(); | |
657 | a2 = cb0.array_two(); | |
658 | ||
659 | BOOST_CHECK(a1.second == 0); | |
660 | BOOST_CHECK(a2.second == 0); | |
661 | ||
662 | const CB_CONTAINER<MyInteger> ccb(10, 1); | |
663 | ca1 = ccb.array_one(); | |
664 | ca2 = ccb.array_two(); | |
665 | ||
666 | BOOST_CHECK(ca1.second == 10); | |
667 | BOOST_CHECK(*(ca1.first) == 1); | |
668 | BOOST_CHECK(ca2.second == 0); | |
669 | ||
670 | generic_test(cb); | |
671 | generic_test(cb0); | |
672 | } | |
673 | ||
674 | void capacity_and_reserve_test() { | |
675 | ||
676 | CB_CONTAINER<MyInteger> cb1(0); | |
677 | CB_CONTAINER<MyInteger> cb2(10); | |
678 | ||
679 | BOOST_CHECK(cb1.capacity() == 0); | |
680 | BOOST_CHECK(cb1.size() == 0); | |
681 | BOOST_CHECK(cb1.reserve() == 0); | |
682 | BOOST_CHECK(cb1.full()); | |
683 | BOOST_CHECK(cb1.empty()); | |
684 | BOOST_CHECK(cb1.reserve() == cb1.capacity() - cb1.size()); | |
685 | BOOST_CHECK(cb2.capacity() == 10); | |
686 | BOOST_CHECK(cb2.size() == 0); | |
687 | BOOST_CHECK(cb2.reserve() == 10); | |
688 | BOOST_CHECK(cb2.reserve() == cb2.capacity() - cb2.size()); | |
689 | ||
690 | cb1.push_back(1); | |
691 | cb2.push_back(2); | |
692 | cb2.push_back(2); | |
693 | cb2.push_back(2); | |
694 | ||
695 | BOOST_CHECK(cb1.capacity() == 0); | |
696 | BOOST_CHECK(cb1.size() == 0); | |
697 | BOOST_CHECK(cb1.reserve() == 0); | |
698 | BOOST_CHECK(cb1.full()); | |
699 | BOOST_CHECK(cb1.empty()); | |
700 | BOOST_CHECK(cb1.reserve() == cb1.capacity() - cb1.size()); | |
701 | BOOST_CHECK(cb2.capacity() == 10); | |
702 | BOOST_CHECK(cb2.size() == 3); | |
703 | BOOST_CHECK(cb2.reserve() == 7); | |
704 | BOOST_CHECK(cb2.reserve() == cb2.capacity() - cb2.size()); | |
705 | ||
706 | generic_test(cb1); | |
707 | generic_test(cb2); | |
708 | } | |
709 | ||
710 | void full_and_empty_test() { | |
711 | ||
712 | CB_CONTAINER<MyInteger> cb1(10); | |
713 | CB_CONTAINER<MyInteger> cb2(3); | |
714 | CB_CONTAINER<MyInteger> cb3(2); | |
715 | CB_CONTAINER<MyInteger> cb4(2); | |
716 | cb2.push_back(1); | |
717 | cb2.push_back(3); | |
718 | cb2.push_back(1); | |
719 | cb2.push_back(1); | |
720 | cb2.push_back(1); | |
721 | cb3.push_back(3); | |
722 | cb3.push_back(1); | |
723 | cb4.push_back(1); | |
724 | ||
725 | BOOST_CHECK(cb1.empty()); | |
726 | BOOST_CHECK(cb2.full()); | |
727 | BOOST_CHECK(cb3.full()); | |
728 | BOOST_CHECK(!cb4.empty()); | |
729 | BOOST_CHECK(!cb4.full()); | |
730 | ||
731 | generic_test(cb1); | |
732 | generic_test(cb2); | |
733 | generic_test(cb3); | |
734 | generic_test(cb4); | |
735 | } | |
736 | ||
737 | void set_capacity_test() { | |
738 | ||
739 | CB_CONTAINER<MyInteger> cb1(10); | |
740 | cb1.push_back(2); | |
741 | cb1.push_back(3); | |
742 | cb1.push_back(1); | |
743 | cb1.set_capacity(5); | |
744 | CB_CONTAINER<MyInteger> cb2(3); | |
745 | cb2.push_back(2); | |
746 | cb2.push_back(3); | |
747 | cb2.push_back(1); | |
748 | cb2.set_capacity(10); | |
749 | CB_CONTAINER<MyInteger> cb3(5); | |
750 | cb3.push_back(2); | |
751 | cb3.push_back(3); | |
752 | cb3.push_back(1); | |
753 | cb3.set_capacity(2); | |
754 | ||
755 | BOOST_CHECK(cb1.size() == 3); | |
756 | BOOST_CHECK(cb1[0] == 2); | |
757 | BOOST_CHECK(cb1[2] == 1); | |
758 | BOOST_CHECK(cb1.capacity() == 5); | |
759 | BOOST_CHECK(cb2.size() == 3); | |
760 | BOOST_CHECK(cb2[0] == 2); | |
761 | BOOST_CHECK(cb2[2] == 1); | |
762 | BOOST_CHECK(cb2.capacity() == 10); | |
763 | BOOST_CHECK(cb3.size() == 2); | |
764 | BOOST_CHECK(cb3[0] == 2); | |
765 | BOOST_CHECK(cb3[1] == 3); | |
766 | BOOST_CHECK(cb3.capacity() == 2); | |
767 | ||
768 | cb3.set_capacity(2); | |
769 | ||
770 | BOOST_CHECK(cb3.size() == 2); | |
771 | BOOST_CHECK(cb3[0] == 2); | |
772 | BOOST_CHECK(cb3[1] == 3); | |
773 | BOOST_CHECK(cb3.capacity() == 2); | |
774 | ||
775 | cb3.set_capacity(0); | |
776 | ||
777 | BOOST_CHECK(cb3.size() == 0); | |
778 | BOOST_CHECK(cb3.capacity() == 0); | |
779 | ||
780 | generic_test(cb1); | |
781 | generic_test(cb2); | |
782 | generic_test(cb3); | |
783 | } | |
784 | ||
785 | void rset_capacity_test() { | |
786 | ||
787 | CB_CONTAINER<MyInteger> cb1(10); | |
788 | cb1.push_back(2); | |
789 | cb1.push_back(3); | |
790 | cb1.push_back(1); | |
791 | cb1.rset_capacity(5); | |
792 | CB_CONTAINER<MyInteger> cb2(3); | |
793 | cb2.push_back(2); | |
794 | cb2.push_back(3); | |
795 | cb2.push_back(1); | |
796 | cb2.rset_capacity(10); | |
797 | CB_CONTAINER<MyInteger> cb3(5); | |
798 | cb3.push_back(2); | |
799 | cb3.push_back(3); | |
800 | cb3.push_back(1); | |
801 | cb3.rset_capacity(2); | |
802 | ||
803 | BOOST_CHECK(cb1.size() == 3); | |
804 | BOOST_CHECK(cb1[0] == 2); | |
805 | BOOST_CHECK(cb1[2] == 1); | |
806 | BOOST_CHECK(cb1.capacity() == 5); | |
807 | BOOST_CHECK(cb2.size() == 3); | |
808 | BOOST_CHECK(cb2[0] == 2); | |
809 | BOOST_CHECK(cb2[2] == 1); | |
810 | BOOST_CHECK(cb2.capacity() == 10); | |
811 | BOOST_CHECK(cb3.size() == 2); | |
812 | BOOST_CHECK(cb3[0] == 3); | |
813 | BOOST_CHECK(cb3[1] == 1); | |
814 | BOOST_CHECK(cb3.capacity() == 2); | |
815 | ||
816 | cb3.rset_capacity(2); | |
817 | ||
818 | BOOST_CHECK(cb3.size() == 2); | |
819 | BOOST_CHECK(cb3[0] == 3); | |
820 | BOOST_CHECK(cb3[1] == 1); | |
821 | BOOST_CHECK(cb3.capacity() == 2); | |
822 | ||
823 | cb3.rset_capacity(0); | |
824 | ||
825 | BOOST_CHECK(cb3.size() == 0); | |
826 | BOOST_CHECK(cb3.capacity() == 0); | |
827 | ||
828 | generic_test(cb1); | |
829 | generic_test(cb2); | |
830 | generic_test(cb3); | |
831 | } | |
832 | ||
833 | void resize_test() { | |
834 | ||
835 | CB_CONTAINER<MyInteger> cb1(10); | |
836 | cb1.push_back(1); | |
837 | cb1.push_back(2); | |
838 | cb1.push_back(3); | |
839 | cb1.push_back(4); | |
840 | cb1.resize(20, 5); | |
841 | CB_CONTAINER<MyInteger> cb2(10); | |
842 | cb2.push_back(1); | |
843 | cb2.push_back(2); | |
844 | cb2.push_back(3); | |
845 | cb2.push_back(4); | |
846 | cb2.resize(2); | |
847 | CB_CONTAINER<MyInteger> cb3(10, 1); | |
848 | cb3.resize(0); | |
849 | CB_CONTAINER<MyInteger> cb4(10, 1); | |
850 | cb4.resize(10); | |
851 | ||
852 | BOOST_CHECK(cb1.size() == 20); | |
853 | BOOST_CHECK(cb1.capacity() == 20); | |
854 | BOOST_CHECK(cb1[0] == 1); | |
855 | BOOST_CHECK(cb1[3] == 4); | |
856 | BOOST_CHECK(cb1[4] == 5); | |
857 | BOOST_CHECK(cb1[19] == 5); | |
858 | BOOST_CHECK(cb2.size() == 2); | |
859 | BOOST_CHECK(cb2.capacity() == 10); | |
860 | BOOST_CHECK(cb2[0] == 1); | |
861 | BOOST_CHECK(cb2[1] == 2); | |
862 | BOOST_CHECK(cb3.size() == 0); | |
863 | BOOST_CHECK(cb3.capacity() == 10); | |
864 | BOOST_CHECK(cb4.size() == 10); | |
865 | BOOST_CHECK(cb4.capacity() == 10); | |
866 | BOOST_CHECK(cb4[0] == 1); | |
867 | BOOST_CHECK(cb4[9] == 1); | |
868 | ||
869 | generic_test(cb1); | |
870 | generic_test(cb2); | |
871 | generic_test(cb3); | |
872 | generic_test(cb4); | |
873 | } | |
874 | ||
875 | void rresize_test() { | |
876 | ||
877 | CB_CONTAINER<MyInteger> cb1(10); | |
878 | cb1.push_back(1); | |
879 | cb1.push_back(2); | |
880 | cb1.push_back(3); | |
881 | cb1.push_back(4); | |
882 | cb1.rresize(20, 5); | |
883 | CB_CONTAINER<MyInteger> cb2(10); | |
884 | cb2.push_back(1); | |
885 | cb2.push_back(2); | |
886 | cb2.push_back(3); | |
887 | cb2.push_back(4); | |
888 | cb2.rresize(2); | |
889 | CB_CONTAINER<MyInteger> cb3(10, 1); | |
890 | cb3.rresize(0); | |
891 | CB_CONTAINER<MyInteger> cb4(10, 1); | |
892 | cb4.rresize(10); | |
893 | ||
894 | BOOST_CHECK(cb1.size() == 20); | |
895 | BOOST_CHECK(cb1.capacity() == 20); | |
896 | BOOST_CHECK(cb1[0] == 5); | |
897 | BOOST_CHECK(cb1[15] == 5); | |
898 | BOOST_CHECK(cb1[16] == 1); | |
899 | BOOST_CHECK(cb1[19] == 4); | |
900 | BOOST_CHECK(cb2.size() == 2); | |
901 | BOOST_CHECK(cb2.capacity() == 10); | |
902 | BOOST_CHECK(cb2[0] == 3); | |
903 | BOOST_CHECK(cb2[1] == 4); | |
904 | BOOST_CHECK(cb3.size() == 0); | |
905 | BOOST_CHECK(cb3.capacity() == 10); | |
906 | BOOST_CHECK(cb4.size() == 10); | |
907 | BOOST_CHECK(cb4.capacity() == 10); | |
908 | BOOST_CHECK(cb4[0] == 1); | |
909 | BOOST_CHECK(cb4[9] == 1); | |
910 | ||
911 | generic_test(cb1); | |
912 | generic_test(cb2); | |
913 | generic_test(cb3); | |
914 | generic_test(cb4); | |
915 | } | |
916 | ||
917 | void constructor_test() { | |
918 | ||
919 | CB_CONTAINER<MyInteger> cb0; | |
920 | BOOST_CHECK(cb0.capacity() == 0); | |
921 | BOOST_CHECK(cb0.size() == 0); | |
922 | ||
923 | cb0.push_back(1); | |
924 | cb0.push_back(2); | |
925 | cb0.push_back(3); | |
926 | ||
927 | BOOST_CHECK(cb0.size() == 0); | |
928 | BOOST_CHECK(cb0.capacity() == 0); | |
929 | ||
930 | CB_CONTAINER<MyInteger> cb1(3); | |
931 | CB_CONTAINER<MyInteger> cb2(3, 2); | |
932 | vector<int> v; | |
933 | v.push_back(1); | |
934 | v.push_back(2); | |
935 | v.push_back(3); | |
936 | v.push_back(4); | |
937 | v.push_back(5); | |
938 | CB_CONTAINER<MyInteger> cb3(v.begin(), v.end()); | |
939 | CB_CONTAINER<MyInteger> cb4(3, v.begin(), v.end()); | |
940 | CB_CONTAINER<MyInteger> cb5(10, v.begin(), v.end()); | |
941 | CB_CONTAINER<MyInteger> cb6(10, 3, MyInteger(2)); | |
942 | ||
943 | BOOST_CHECK(cb1.size() == 0); | |
944 | BOOST_CHECK(cb1.capacity() == 3); | |
945 | BOOST_CHECK(cb2[0] == 2); | |
946 | BOOST_CHECK(cb2.full()); | |
947 | BOOST_CHECK(cb2[0] == 2); | |
948 | BOOST_CHECK(cb2[1] == 2); | |
949 | BOOST_CHECK(cb2[2] == 2); | |
950 | BOOST_CHECK(cb3.size() == 5); | |
951 | BOOST_CHECK(cb3.capacity() == 5); | |
952 | BOOST_CHECK(cb3.full()); | |
953 | BOOST_CHECK(cb3[0] == 1); | |
954 | BOOST_CHECK(cb3[4] == 5); | |
955 | BOOST_CHECK(cb4.size() == 3); | |
956 | BOOST_CHECK(cb4.capacity() == 3); | |
957 | BOOST_CHECK(cb4.full()); | |
958 | BOOST_CHECK(cb4[0] == 3); | |
959 | BOOST_CHECK(cb4[2] == 5); | |
960 | BOOST_CHECK(cb5.size() == 5); | |
961 | BOOST_CHECK(cb5.capacity() == 10); | |
962 | BOOST_CHECK(!cb5.full()); | |
963 | BOOST_CHECK(cb5[0] == 1); | |
964 | BOOST_CHECK(cb5[4] == 5); | |
965 | BOOST_CHECK(cb6.size() == 3); | |
966 | BOOST_CHECK(cb6.capacity() == 10); | |
967 | BOOST_CHECK(!cb6.full()); | |
968 | BOOST_CHECK(cb6[0] == 2); | |
969 | BOOST_CHECK(cb6[2] == 2); | |
970 | ||
971 | cb5.push_back(6); | |
972 | cb6.push_back(6); | |
973 | ||
974 | BOOST_CHECK(cb5[5] == 6); | |
975 | BOOST_CHECK(cb5[0] == 1); | |
976 | BOOST_CHECK(cb5.size() == 6); | |
977 | BOOST_CHECK(cb6[3] == 6); | |
978 | BOOST_CHECK(cb6.size() == 4); | |
979 | BOOST_CHECK(cb6[0] == 2); | |
980 | ||
981 | #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) | |
982 | ||
983 | CB_CONTAINER<int> cb7(MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
984 | CB_CONTAINER<int> cb8(3, MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
985 | ||
986 | BOOST_CHECK(cb7.capacity() == 5); | |
987 | BOOST_CHECK(cb8.capacity() == 3); | |
988 | ||
989 | #endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) | |
990 | ||
991 | generic_test(cb1); | |
992 | generic_test(cb2); | |
993 | generic_test(cb3); | |
994 | generic_test(cb4); | |
995 | generic_test(cb5); | |
996 | generic_test(cb6); | |
997 | } | |
998 | ||
999 | void assign_test() { | |
1000 | ||
1001 | CB_CONTAINER<MyInteger> cb1(4); | |
1002 | cb1.push_back(1); | |
1003 | cb1.push_back(2); | |
1004 | cb1.push_back(3); | |
1005 | cb1.push_back(4); | |
1006 | cb1.push_back(5); | |
1007 | cb1.assign(3, 8); | |
1008 | BOOST_CHECK(cb1.size() == 3); | |
1009 | BOOST_CHECK(cb1.capacity() == 3); | |
1010 | BOOST_CHECK(cb1[0] == 8); | |
1011 | BOOST_CHECK(cb1[2] == 8); | |
1012 | ||
1013 | cb1.assign(6, 7); | |
1014 | BOOST_CHECK(cb1.size() == 6); | |
1015 | BOOST_CHECK(cb1.capacity() == 6); | |
1016 | BOOST_CHECK(cb1[0] == 7); | |
1017 | BOOST_CHECK(cb1[5] == 7); | |
1018 | ||
1019 | CB_CONTAINER<float> cb2(4); | |
1020 | cb2.assign(3, 1.1f); | |
1021 | BOOST_CHECK(cb2[0] == 1.1f); | |
1022 | ||
1023 | CB_CONTAINER<MyInteger> cb3(5); | |
1024 | cb3.push_back(1); | |
1025 | cb3.push_back(2); | |
1026 | cb3.push_back(3); | |
1027 | cb3.assign((size_t)10, 1); // The size_t cast is not needed. It is present here just because of testing purposes. | |
1028 | BOOST_CHECK(cb3[0] == 1); | |
1029 | BOOST_CHECK(cb3[9] == 1); | |
1030 | BOOST_CHECK(cb3.size() == 10); | |
1031 | BOOST_CHECK(cb3.capacity() == 10); | |
1032 | ||
1033 | #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) | |
1034 | ||
1035 | vector<int> v; | |
1036 | v.push_back(1); | |
1037 | v.push_back(2); | |
1038 | v.push_back(3); | |
1039 | v.push_back(4); | |
1040 | v.push_back(5); | |
1041 | ||
1042 | CB_CONTAINER<int> cb4(3); | |
1043 | cb4.assign(MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
1044 | CB_CONTAINER<int> cb5(3); | |
1045 | cb5.assign(4, MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
1046 | ||
1047 | BOOST_CHECK(cb4.capacity() == 5); | |
1048 | BOOST_CHECK(cb5.capacity() == 4); | |
1049 | ||
1050 | #endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) | |
1051 | ||
1052 | generic_test(cb1); | |
1053 | generic_test(cb3); | |
1054 | } | |
1055 | ||
1056 | void copy_constructor_and_assign_test() { | |
1057 | ||
1058 | CB_CONTAINER<MyInteger> cb1(4); | |
1059 | cb1.push_back(1); | |
1060 | cb1.push_back(2); | |
1061 | cb1.push_back(3); | |
1062 | cb1.push_back(4); | |
1063 | cb1.push_back(5); | |
1064 | CB_CONTAINER<MyInteger> cb2 = cb1; | |
1065 | ||
1066 | BOOST_CHECK(cb1 == cb2); | |
1067 | BOOST_CHECK(cb2.capacity() == 4); | |
1068 | BOOST_CHECK(cb2[0] == 2); | |
1069 | BOOST_CHECK(cb2[3] == 5); | |
1070 | ||
1071 | CB_CONTAINER<MyInteger> cb3(20); | |
1072 | cb1.pop_back(); | |
1073 | CB_CONTAINER<MyInteger> cb4(3); | |
1074 | cb3 = cb2; | |
1075 | cb3 = cb3; | |
1076 | cb4 = cb1; | |
1077 | CB_CONTAINER<MyInteger> cb5 = cb1; | |
1078 | ||
1079 | BOOST_CHECK(cb3 == cb2); | |
1080 | BOOST_CHECK(cb4 == cb1); | |
1081 | BOOST_CHECK(cb2.full()); | |
1082 | BOOST_CHECK(cb2[0] == 2); | |
1083 | BOOST_CHECK(cb3.full()); | |
1084 | BOOST_CHECK(cb3.capacity() == 4); | |
1085 | BOOST_CHECK(cb4.capacity() == 4); | |
1086 | BOOST_CHECK(!cb4.full()); | |
1087 | BOOST_CHECK(*(cb4.end() - 1) == 4); | |
1088 | BOOST_CHECK(cb1 == cb5); | |
1089 | BOOST_CHECK(cb5.capacity() == 4); | |
1090 | BOOST_CHECK(cb2[0] == 2); | |
1091 | BOOST_CHECK(cb2[2] == 4); | |
1092 | ||
1093 | generic_test(cb1); | |
1094 | generic_test(cb2); | |
1095 | generic_test(cb3); | |
1096 | generic_test(cb4); | |
1097 | generic_test(cb5); | |
1098 | } | |
1099 | ||
1100 | void swap_test() { | |
1101 | ||
1102 | CB_CONTAINER<MyInteger> cb1(2); | |
1103 | cb1.push_back(1); | |
1104 | cb1.push_back(2); | |
1105 | cb1.push_back(3); | |
1106 | CB_CONTAINER<MyInteger> cb2(5); | |
1107 | cb2.push_back(8); | |
1108 | cb2.swap(cb1); | |
1109 | cb2.swap(cb2); | |
1110 | ||
1111 | BOOST_CHECK(cb2.capacity() == 2); | |
1112 | BOOST_CHECK(cb2[0] == 2); | |
1113 | BOOST_CHECK(cb2.full()); | |
1114 | BOOST_CHECK(cb1.capacity() == 5); | |
1115 | BOOST_CHECK(cb1[0] == 8); | |
1116 | BOOST_CHECK(cb1.size() == 1); | |
1117 | ||
1118 | generic_test(cb1); | |
1119 | generic_test(cb2); | |
1120 | } | |
1121 | ||
1122 | void push_back_test() { | |
1123 | ||
1124 | CB_CONTAINER<MyDefaultConstructible> cb1(5); | |
1125 | cb1.push_back(); | |
1126 | cb1.push_back(MyDefaultConstructible(2)); | |
1127 | BOOST_CHECK(cb1[0].m_n == 1); | |
1128 | BOOST_CHECK(cb1[1].m_n == 2); | |
1129 | ||
1130 | CB_CONTAINER<MyInteger> cb2(5); | |
1131 | cb2.push_back(); | |
1132 | BOOST_CHECK(cb2.back() == CB_CONTAINER<MyInteger>::value_type()); | |
1133 | ||
1134 | cb2.push_back(1); | |
1135 | BOOST_CHECK(cb2.back() == 1); | |
1136 | ||
1137 | generic_test(cb2); | |
1138 | } | |
1139 | ||
1140 | void pop_back_test() { | |
1141 | ||
1142 | CB_CONTAINER<MyInteger> cb(4); | |
1143 | cb.push_back(1); | |
1144 | cb.push_back(2); | |
1145 | cb.push_back(3); | |
1146 | cb.push_back(4); | |
1147 | cb.push_back(5); | |
1148 | cb.pop_back(); | |
1149 | ||
1150 | BOOST_CHECK(cb.size() == 3); | |
1151 | BOOST_CHECK(!cb.full()); | |
1152 | BOOST_CHECK(cb[0] == 2); | |
1153 | ||
1154 | generic_test(cb); | |
1155 | } | |
1156 | ||
1157 | void insert_test() { | |
1158 | ||
1159 | CB_CONTAINER<MyInteger> cb1(4); | |
1160 | cb1.push_back(1); | |
1161 | cb1.push_back(2); | |
1162 | cb1.push_back(3); | |
1163 | CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1; | |
1164 | it1 = cb1.insert(it1, 10); | |
1165 | CB_CONTAINER<MyInteger> cb2(4); | |
1166 | cb2.push_back(1); | |
1167 | cb2.insert(cb2.begin()); | |
1168 | cb2.insert(cb2.begin(), -1); | |
1169 | CB_CONTAINER<MyInteger>::iterator it2 = cb2.begin() + 1; | |
1170 | it2 = cb2.insert(it2, 5); | |
1171 | CB_CONTAINER<MyInteger> cb3(2); | |
1172 | cb3.insert(cb3.end(), 10); | |
1173 | cb3.insert(cb3.end(), 20); | |
1174 | cb3.insert(cb3.begin(), 30); | |
1175 | cb3.insert(cb3.end(), 40); | |
1176 | ||
1177 | BOOST_CHECK(cb1[1] == 10); | |
1178 | BOOST_CHECK(*it1 == 10); | |
1179 | BOOST_CHECK(cb1.full()); | |
1180 | BOOST_CHECK(cb2[1] == 5); | |
1181 | BOOST_CHECK(*it2 == 5); | |
1182 | BOOST_CHECK(cb2.full()); | |
1183 | BOOST_CHECK(cb3[0] == 20); | |
1184 | BOOST_CHECK(cb3[1] == 40); | |
1185 | ||
1186 | generic_test(cb1); | |
1187 | generic_test(cb2); | |
1188 | generic_test(cb3); | |
1189 | } | |
1190 | ||
1191 | void insert_n_test() { | |
1192 | ||
1193 | CB_CONTAINER<MyInteger> cb1(4); | |
1194 | cb1.push_back(1); | |
1195 | cb1.push_back(2); | |
1196 | cb1.push_back(3); | |
1197 | cb1.insert(cb1.begin() + 1, 2, 10); | |
1198 | CB_CONTAINER<MyInteger> cb2(2, 3); | |
1199 | cb2.insert(cb2.begin(), 10, 5); | |
1200 | CB_CONTAINER<MyInteger> cb3(4); | |
1201 | cb3.insert(cb3.end(), 1, 6); | |
1202 | CB_CONTAINER<MyInteger> cb4(6); | |
1203 | cb4.push_back(1); | |
1204 | cb4.push_back(2); | |
1205 | cb4.push_back(3); | |
1206 | cb4.push_back(4); | |
1207 | cb4.insert(cb4.begin() + 2, 5, 6); | |
1208 | cb4.insert(cb4.begin() + 2, 0, 7); | |
1209 | ||
1210 | BOOST_CHECK(cb1.full()); | |
1211 | BOOST_CHECK(cb1[0] == 10); | |
1212 | BOOST_CHECK(cb1[1] == 10); | |
1213 | BOOST_CHECK(cb1[2] == 2); | |
1214 | BOOST_CHECK(cb1[3] == 3); | |
1215 | BOOST_CHECK(cb2[0] == 3); | |
1216 | BOOST_CHECK(cb2[1] == 3); | |
1217 | BOOST_CHECK(cb3[0] == 6); | |
1218 | BOOST_CHECK(cb3.size() == 1); | |
1219 | BOOST_CHECK(cb4.size() == 6); | |
1220 | BOOST_CHECK(cb4[0] == 6); | |
1221 | BOOST_CHECK(cb4[1] == 6); | |
1222 | BOOST_CHECK(cb4[2] == 6); | |
1223 | BOOST_CHECK(cb4[3] == 6); | |
1224 | BOOST_CHECK(cb4[4] == 3); | |
1225 | BOOST_CHECK(cb4[5] == 4); | |
1226 | ||
1227 | generic_test(cb1); | |
1228 | generic_test(cb2); | |
1229 | generic_test(cb3); | |
1230 | generic_test(cb4); | |
1231 | } | |
1232 | ||
1233 | void insert_range_test() { | |
1234 | ||
1235 | vector<int> v; | |
1236 | v.push_back(11); | |
1237 | v.push_back(12); | |
1238 | v.push_back(13); | |
1239 | CB_CONTAINER<MyInteger> cb1(4); | |
1240 | cb1.push_back(1); | |
1241 | cb1.push_back(2); | |
1242 | cb1.push_back(3); | |
1243 | cb1.insert(cb1.begin() + 1, v.begin(), v.end()); | |
1244 | CB_CONTAINER<MyInteger> cb2(2, 2); | |
1245 | cb2.insert(cb2.end(), v.begin(), v.end()); | |
1246 | CB_CONTAINER<MyInteger> cb3(5); | |
1247 | cb3.insert(cb3.end(), v.end(), v.end()); | |
1248 | CB_CONTAINER<MyInteger> cb4(5); | |
1249 | cb4.insert(cb4.end(), v.begin(), v.begin() + 1); | |
1250 | MyInteger array[] = { 5, 6, 7, 8, 9 }; | |
1251 | CB_CONTAINER<MyInteger> cb5(6); | |
1252 | cb5.push_back(1); | |
1253 | cb5.push_back(2); | |
1254 | cb5.push_back(3); | |
1255 | cb5.push_back(4); | |
1256 | cb5.insert(cb5.begin() + 2, array, array + 5); | |
1257 | cb5.insert(cb5.begin(), array, array + 5); | |
1258 | ||
1259 | BOOST_CHECK(cb1.full()); | |
1260 | BOOST_CHECK(cb1[0] == 12); | |
1261 | BOOST_CHECK(cb1[1] == 13); | |
1262 | BOOST_CHECK(cb1[2] == 2); | |
1263 | BOOST_CHECK(cb1[3] == 3); | |
1264 | BOOST_CHECK(cb2[0] == 12); | |
1265 | BOOST_CHECK(cb2[1] == 13); | |
1266 | BOOST_CHECK(cb3.empty()); | |
1267 | BOOST_CHECK(cb4[0] == 11); | |
1268 | BOOST_CHECK(cb4.size() == 1); | |
1269 | BOOST_CHECK(cb5.size() == 6); | |
1270 | BOOST_CHECK(cb5[0] == 6); | |
1271 | BOOST_CHECK(cb5[1] == 7); | |
1272 | BOOST_CHECK(cb5[2] == 8); | |
1273 | BOOST_CHECK(cb5[3] == 9); | |
1274 | BOOST_CHECK(cb5[4] == 3); | |
1275 | BOOST_CHECK(cb5[5] == 4); | |
1276 | ||
1277 | #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) | |
1278 | ||
1279 | v.clear(); | |
1280 | v.push_back(1); | |
1281 | v.push_back(2); | |
1282 | v.push_back(3); | |
1283 | v.push_back(4); | |
1284 | v.push_back(5); | |
1285 | ||
1286 | CB_CONTAINER<int> cb6(4); | |
1287 | cb6.push_back(0); | |
1288 | cb6.push_back(-1); | |
1289 | cb6.push_back(-2); | |
1290 | cb6.insert(cb6.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
1291 | v.clear(); | |
1292 | v.push_back(11); | |
1293 | v.push_back(12); | |
1294 | v.push_back(13); | |
1295 | CB_CONTAINER<int> cb7(4); | |
1296 | cb7.push_back(1); | |
1297 | cb7.push_back(2); | |
1298 | cb7.push_back(3); | |
1299 | cb7.insert(cb7.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
1300 | CB_CONTAINER<int> cb8(2, 2); | |
1301 | cb8.insert(cb8.end(), MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
1302 | CB_CONTAINER<int> cb9(5); | |
1303 | cb9.insert(cb9.end(), MyInputIterator(v.end()), MyInputIterator(v.end())); | |
1304 | CB_CONTAINER<int> cb10(5); | |
1305 | cb10.insert(cb10.end(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 1)); | |
1306 | v.clear(); | |
1307 | v.push_back(5); | |
1308 | v.push_back(6); | |
1309 | v.push_back(7); | |
1310 | v.push_back(8); | |
1311 | v.push_back(9); | |
1312 | CB_CONTAINER<int> cb11(6); | |
1313 | cb11.push_back(1); | |
1314 | cb11.push_back(2); | |
1315 | cb11.push_back(3); | |
1316 | cb11.push_back(4); | |
1317 | cb11.insert(cb11.begin() + 2, MyInputIterator(v.begin()), MyInputIterator(v.begin() + 5)); | |
1318 | cb11.insert(cb11.begin(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 5)); | |
1319 | ||
1320 | BOOST_CHECK(cb6.capacity() == 4); | |
1321 | BOOST_CHECK(cb6[0] == 4); | |
1322 | BOOST_CHECK(cb6[3] == -2); | |
1323 | BOOST_CHECK(cb7.full()); | |
1324 | BOOST_CHECK(cb7[0] == 12); | |
1325 | BOOST_CHECK(cb7[1] == 13); | |
1326 | BOOST_CHECK(cb7[2] == 2); | |
1327 | BOOST_CHECK(cb7[3] == 3); | |
1328 | BOOST_CHECK(cb8[0] == 12); | |
1329 | BOOST_CHECK(cb8[1] == 13); | |
1330 | BOOST_CHECK(cb9.empty()); | |
1331 | BOOST_CHECK(cb10[0] == 11); | |
1332 | BOOST_CHECK(cb10.size() == 1); | |
1333 | BOOST_CHECK(cb11.size() == 6); | |
1334 | BOOST_CHECK(cb11[0] == 6); | |
1335 | BOOST_CHECK(cb11[1] == 7); | |
1336 | BOOST_CHECK(cb11[2] == 8); | |
1337 | BOOST_CHECK(cb11[3] == 9); | |
1338 | BOOST_CHECK(cb11[4] == 3); | |
1339 | BOOST_CHECK(cb11[5] == 4); | |
1340 | ||
1341 | #endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) | |
1342 | ||
1343 | generic_test(cb1); | |
1344 | generic_test(cb2); | |
1345 | generic_test(cb3); | |
1346 | generic_test(cb4); | |
1347 | generic_test(cb5); | |
1348 | } | |
1349 | ||
1350 | void push_front_test() { | |
1351 | ||
1352 | CB_CONTAINER<MyDefaultConstructible> cb1(5); | |
1353 | cb1.push_front(); | |
1354 | cb1.push_front(MyDefaultConstructible(2)); | |
1355 | BOOST_CHECK(cb1[0].m_n == 2); | |
1356 | BOOST_CHECK(cb1[1].m_n == 1); | |
1357 | ||
1358 | CB_CONTAINER<MyInteger> cb2(5); | |
1359 | cb2.push_front(); | |
1360 | BOOST_CHECK(cb2.front() == CB_CONTAINER<MyInteger>::value_type()); | |
1361 | ||
1362 | cb2.push_front(1); | |
1363 | BOOST_CHECK(cb2.front() == 1); | |
1364 | ||
1365 | CB_CONTAINER<MyInteger> cb3(0); | |
1366 | cb3.push_front(10); | |
1367 | BOOST_CHECK(cb3.empty()); | |
1368 | ||
1369 | generic_test(cb2); | |
1370 | generic_test(cb3); | |
1371 | } | |
1372 | ||
1373 | void pop_front_test() { | |
1374 | ||
1375 | CB_CONTAINER<MyInteger> cb(4); | |
1376 | cb.push_front(1); | |
1377 | cb.push_front(2); | |
1378 | cb.push_front(3); | |
1379 | cb.push_front(4); | |
1380 | cb.push_front(5); | |
1381 | cb.pop_front(); | |
1382 | ||
1383 | BOOST_CHECK(cb.size() == 3); | |
1384 | BOOST_CHECK(!cb.full()); | |
1385 | BOOST_CHECK(cb[0] == 4); | |
1386 | ||
1387 | generic_test(cb); | |
1388 | } | |
1389 | ||
1390 | void rinsert_test() { | |
1391 | ||
1392 | CB_CONTAINER<MyInteger> cb1(4); | |
1393 | cb1.push_front(1); | |
1394 | cb1.push_front(2); | |
1395 | cb1.push_front(3); | |
1396 | CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1; | |
1397 | it1 = cb1.rinsert(it1, 10); | |
1398 | CB_CONTAINER<MyInteger> cb2(4); | |
1399 | cb2.push_front(1); | |
1400 | cb2.rinsert(cb2.begin()); | |
1401 | cb2.rinsert(cb2.begin(), -1); | |
1402 | CB_CONTAINER<MyInteger>::iterator it2 = cb2.end() - 2; | |
1403 | it2 = cb2.rinsert(it2, 5); | |
1404 | CB_CONTAINER<MyInteger> cb3(2); | |
1405 | cb3.rinsert(cb3.begin(), 10); | |
1406 | cb3.rinsert(cb3.begin(), 20); | |
1407 | cb3.rinsert(cb3.end(), 30); | |
1408 | cb3.rinsert(cb3.begin(), 40); | |
1409 | CB_CONTAINER<MyInteger> cb4(4); | |
1410 | cb4.push_back(1); | |
1411 | cb4.push_back(2); | |
1412 | cb4.push_back(3); | |
1413 | CB_CONTAINER<MyInteger>::iterator it3 = cb4.begin() + 1; | |
1414 | it3 = cb4.rinsert(it3, 10); | |
1415 | CB_CONTAINER<MyInteger> cb5(4); | |
1416 | cb5.push_back(1); | |
1417 | cb5.rinsert(cb5.begin(), 0); | |
1418 | cb5.rinsert(cb5.begin(), -1); | |
1419 | CB_CONTAINER<MyInteger>::iterator it4 = cb5.begin() + 1; | |
1420 | it4 = cb5.rinsert(it4, 5); | |
1421 | CB_CONTAINER<MyInteger> cb6(2); | |
1422 | cb6.rinsert(cb6.end(), 10); | |
1423 | cb6.rinsert(cb6.end(), 20); | |
1424 | cb6.rinsert(cb6.begin(), 30); | |
1425 | cb6.rinsert(cb6.end(), 40); | |
1426 | CB_CONTAINER<MyInteger> cb7(6); | |
1427 | cb7.push_back(1); | |
1428 | cb7.push_back(2); | |
1429 | cb7.push_back(3); | |
1430 | cb7.push_back(4); | |
1431 | cb7.rinsert(cb7.begin() + 2, 5, 6); | |
1432 | ||
1433 | BOOST_CHECK(cb1[1] == 10); | |
1434 | BOOST_CHECK(*it1 == 10); | |
1435 | BOOST_CHECK(cb1.full()); | |
1436 | BOOST_CHECK(cb2[1] == 5); | |
1437 | BOOST_CHECK(*it2 == 5); | |
1438 | BOOST_CHECK(cb2.full()); | |
1439 | BOOST_CHECK(cb2[3] == 1); | |
1440 | BOOST_CHECK(cb3[0] == 40); | |
1441 | BOOST_CHECK(cb3[1] == 20); | |
1442 | BOOST_CHECK(cb4[1] == 10); | |
1443 | BOOST_CHECK(*it3 == 10); | |
1444 | BOOST_CHECK(cb4.full()); | |
1445 | BOOST_CHECK(cb5[1] == 5); | |
1446 | BOOST_CHECK(*it4 == 5); | |
1447 | BOOST_CHECK(cb5.full()); | |
1448 | BOOST_CHECK(cb6[0] == 30); | |
1449 | BOOST_CHECK(cb6[1] == 10); | |
1450 | BOOST_CHECK(cb7.size() == 6); | |
1451 | BOOST_CHECK(cb7[0] == 1); | |
1452 | BOOST_CHECK(cb7[1] == 2); | |
1453 | BOOST_CHECK(cb7[2] == 6); | |
1454 | BOOST_CHECK(cb7[3] == 6); | |
1455 | BOOST_CHECK(cb7[4] == 6); | |
1456 | BOOST_CHECK(cb7[5] == 6); | |
1457 | ||
1458 | generic_test(cb1); | |
1459 | generic_test(cb2); | |
1460 | generic_test(cb3); | |
1461 | generic_test(cb4); | |
1462 | generic_test(cb5); | |
1463 | generic_test(cb6); | |
1464 | generic_test(cb7); | |
1465 | } | |
1466 | ||
1467 | void rinsert_n_test() { | |
1468 | ||
1469 | CB_CONTAINER<MyInteger> cb1(4); | |
1470 | cb1.push_front(1); | |
1471 | cb1.push_front(2); | |
1472 | cb1.push_front(3); | |
1473 | cb1.rinsert(cb1.begin() + 1, 2, 10); | |
1474 | CB_CONTAINER<MyInteger> cb2(2, 3); | |
1475 | cb2.rinsert(cb2.begin(), 10, 5); | |
1476 | CB_CONTAINER<MyInteger> cb3(4); | |
1477 | cb3.rinsert(cb3.end(), 1, 6); | |
1478 | CB_CONTAINER<MyInteger> cb4(4); | |
1479 | cb4.push_back(1); | |
1480 | cb4.push_back(2); | |
1481 | cb4.push_back(3); | |
1482 | cb4.rinsert(cb4.begin() + 1, 2, 10); | |
1483 | MyInteger array[] = { 5, 6, 7, 8, 9 }; | |
1484 | CB_CONTAINER<MyInteger> cb5(6); | |
1485 | cb5.push_back(1); | |
1486 | cb5.push_back(2); | |
1487 | cb5.push_back(3); | |
1488 | cb5.push_back(4); | |
1489 | cb5.rinsert(cb5.begin() + 2, array, array + 5); | |
1490 | cb5.rinsert(cb5.end(), array, array + 5); | |
1491 | ||
1492 | BOOST_CHECK(cb1.full()); | |
1493 | BOOST_CHECK(cb1[0] == 3); | |
1494 | BOOST_CHECK(cb1[1] == 10); | |
1495 | BOOST_CHECK(cb1[2] == 10); | |
1496 | BOOST_CHECK(cb1[3] == 2); | |
1497 | BOOST_CHECK(cb2[0] == 5); | |
1498 | BOOST_CHECK(cb2[1] == 5); | |
1499 | BOOST_CHECK(cb3[0] == 6); | |
1500 | BOOST_CHECK(cb3.size() == 1); | |
1501 | BOOST_CHECK(cb4.full()); | |
1502 | BOOST_CHECK(cb4[0] == 1); | |
1503 | BOOST_CHECK(cb4[1] == 10); | |
1504 | BOOST_CHECK(cb4[2] == 10); | |
1505 | BOOST_CHECK(cb4[3] == 2); | |
1506 | BOOST_CHECK(cb5.size() == 6); | |
1507 | BOOST_CHECK(cb5[0] == 1); | |
1508 | BOOST_CHECK(cb5[1] == 2); | |
1509 | BOOST_CHECK(cb5[2] == 5); | |
1510 | BOOST_CHECK(cb5[3] == 6); | |
1511 | BOOST_CHECK(cb5[4] == 7); | |
1512 | BOOST_CHECK(cb5[5] == 8); | |
1513 | ||
1514 | generic_test(cb1); | |
1515 | generic_test(cb2); | |
1516 | generic_test(cb3); | |
1517 | generic_test(cb4); | |
1518 | generic_test(cb5); | |
1519 | } | |
1520 | ||
1521 | void rinsert_range_test() { | |
1522 | ||
1523 | vector<int> v; | |
1524 | v.push_back(11); | |
1525 | v.push_back(12); | |
1526 | v.push_back(13); | |
1527 | v.push_back(14); | |
1528 | CB_CONTAINER<MyInteger> cb1(4); | |
1529 | cb1.push_back(1); | |
1530 | cb1.push_back(2); | |
1531 | cb1.push_back(3); | |
1532 | cb1.rinsert(cb1.begin() + 1, v.begin(), v.end()); | |
1533 | CB_CONTAINER<MyInteger> cb2(2, 2); | |
1534 | cb2.rinsert(cb2.begin(), v.begin(), v.end()); | |
1535 | CB_CONTAINER<MyInteger> cb3(5); | |
1536 | cb3.rinsert(cb3.begin(), v.end(), v.end()); | |
1537 | CB_CONTAINER<MyInteger> cb4(5); | |
1538 | cb4.rinsert(cb4.begin(), v.begin(), v.begin() + 1); | |
1539 | ||
1540 | BOOST_CHECK(cb1.full()); | |
1541 | BOOST_CHECK(cb1[0] == 1); | |
1542 | BOOST_CHECK(cb1[1] == 11); | |
1543 | BOOST_CHECK(cb1[2] == 12); | |
1544 | BOOST_CHECK(cb1[3] == 13); | |
1545 | BOOST_CHECK(cb2[0] == 11); | |
1546 | BOOST_CHECK(cb2[1] == 12); | |
1547 | BOOST_CHECK(cb3.empty()); | |
1548 | BOOST_CHECK(cb4[0] == 11); | |
1549 | BOOST_CHECK(cb4.size() == 1); | |
1550 | ||
1551 | #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) | |
1552 | ||
1553 | v.clear(); | |
1554 | v.push_back(1); | |
1555 | v.push_back(2); | |
1556 | v.push_back(3); | |
1557 | v.push_back(4); | |
1558 | v.push_back(5); | |
1559 | ||
1560 | CB_CONTAINER<int> cb10(4); | |
1561 | cb10.push_back(0); | |
1562 | cb10.push_back(-1); | |
1563 | cb10.push_back(-2); | |
1564 | cb10.rinsert(cb10.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
1565 | v.clear(); | |
1566 | v.push_back(11); | |
1567 | v.push_back(12); | |
1568 | v.push_back(13); | |
1569 | v.push_back(14); | |
1570 | CB_CONTAINER<int> cb11(4); | |
1571 | cb11.push_back(1); | |
1572 | cb11.push_back(2); | |
1573 | cb11.push_back(3); | |
1574 | cb11.rinsert(cb11.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
1575 | CB_CONTAINER<int> cb12(2, 2); | |
1576 | cb12.rinsert(cb12.begin(), MyInputIterator(v.begin()), MyInputIterator(v.end())); | |
1577 | CB_CONTAINER<int> cb13(5); | |
1578 | cb13.rinsert(cb13.begin(), MyInputIterator(v.end()), MyInputIterator(v.end())); | |
1579 | CB_CONTAINER<int> cb14(5); | |
1580 | cb14.rinsert(cb14.begin(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 1)); | |
1581 | ||
1582 | BOOST_CHECK(cb10.capacity() == 4); | |
1583 | BOOST_CHECK(cb10[0] == 0); | |
1584 | BOOST_CHECK(cb10[3] == 3); | |
1585 | BOOST_CHECK(cb11.full()); | |
1586 | BOOST_CHECK(cb11[0] == 1); | |
1587 | BOOST_CHECK(cb11[1] == 11); | |
1588 | BOOST_CHECK(cb11[2] == 12); | |
1589 | BOOST_CHECK(cb11[3] == 13); | |
1590 | BOOST_CHECK(cb12[0] == 11); | |
1591 | BOOST_CHECK(cb12[1] == 12); | |
1592 | BOOST_CHECK(cb13.empty()); | |
1593 | BOOST_CHECK(cb14[0] == 11); | |
1594 | BOOST_CHECK(cb14.size() == 1); | |
1595 | ||
1596 | #endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) | |
1597 | ||
1598 | generic_test(cb1); | |
1599 | generic_test(cb2); | |
1600 | generic_test(cb3); | |
1601 | generic_test(cb4); | |
1602 | } | |
1603 | ||
1604 | void erase_test() { | |
1605 | ||
1606 | CB_CONTAINER<MyInteger> cb1(4); | |
1607 | cb1.push_back(1); | |
1608 | cb1.push_back(2); | |
1609 | cb1.push_back(3); | |
1610 | CB_CONTAINER<MyInteger>::iterator it1 = cb1.erase(cb1.begin() + 1); | |
1611 | ||
1612 | CB_CONTAINER<MyInteger> cb2(1, 1); | |
1613 | CB_CONTAINER<MyInteger>::iterator it2 = cb2.erase(cb2.begin()); | |
1614 | ||
1615 | CB_CONTAINER<MyInteger> cb3(4); | |
1616 | cb3.push_back(1); | |
1617 | cb3.push_back(2); | |
1618 | cb3.push_back(3); | |
1619 | CB_CONTAINER<MyInteger>::iterator it3 = cb3.erase(cb3.begin() + 2); | |
1620 | ||
1621 | BOOST_CHECK(cb1.size() == 2); | |
1622 | BOOST_CHECK(cb1.capacity() == 4); | |
1623 | BOOST_CHECK(*it1 == 3); | |
1624 | BOOST_CHECK(cb1[0] == 1); | |
1625 | BOOST_CHECK(cb1[1] == 3); | |
1626 | BOOST_CHECK(cb2.size() == 0); | |
1627 | BOOST_CHECK(cb2.capacity() == 1); | |
1628 | BOOST_CHECK(it2 == cb2.end()); | |
1629 | BOOST_CHECK(cb3.size() == 2); | |
1630 | BOOST_CHECK(cb3.capacity() == 4); | |
1631 | BOOST_CHECK(it3 == cb3.end()); | |
1632 | BOOST_CHECK(cb3[0] == 1); | |
1633 | BOOST_CHECK(cb3[1] == 2); | |
1634 | ||
1635 | generic_test(cb1); | |
1636 | generic_test(cb2); | |
1637 | generic_test(cb3); | |
1638 | } | |
1639 | ||
1640 | void erase_range_test() { | |
1641 | ||
1642 | CB_CONTAINER<MyInteger> cb1(4); | |
1643 | cb1.push_back(1); | |
1644 | cb1.push_back(2); | |
1645 | cb1.push_back(3); | |
1646 | cb1.push_back(4); | |
1647 | CB_CONTAINER<MyInteger>::iterator it1 = cb1.erase(cb1.begin() + 1, cb1.begin() + 3); | |
1648 | ||
1649 | CB_CONTAINER<MyInteger> cb2(4); | |
1650 | cb2.push_back(1); | |
1651 | cb2.push_back(2); | |
1652 | cb2.push_back(3); | |
1653 | cb2.push_back(4); | |
1654 | CB_CONTAINER<MyInteger>::iterator it2 = cb2.erase(cb2.begin(), cb2.begin()); | |
1655 | ||
1656 | CB_CONTAINER<MyInteger> cb3(4); | |
1657 | cb3.push_back(1); | |
1658 | cb3.push_back(2); | |
1659 | cb3.push_back(3); | |
1660 | cb3.push_back(4); | |
1661 | CB_CONTAINER<MyInteger>::iterator it3 = cb3.erase(cb3.begin() + 2, cb3.end()); | |
1662 | ||
1663 | CB_CONTAINER<MyInteger> cb4(10, 1); | |
1664 | CB_CONTAINER<MyInteger>::iterator it4 = cb4.erase(cb4.begin(), cb4.end()); | |
1665 | ||
1666 | BOOST_CHECK(cb1.size() == 2); | |
1667 | BOOST_CHECK(cb1.capacity() == 4); | |
1668 | BOOST_CHECK(cb1[0] == 1); | |
1669 | BOOST_CHECK(cb1[1] == 4); | |
1670 | BOOST_CHECK(*it1 == 4); | |
1671 | BOOST_CHECK(cb2.size() == 4); | |
1672 | BOOST_CHECK(cb2[0] == 1); | |
1673 | BOOST_CHECK(cb2[3] == 4); | |
1674 | BOOST_CHECK(*it2 == 1); | |
1675 | BOOST_CHECK(cb3.size() == 2); | |
1676 | BOOST_CHECK(cb3.capacity() == 4); | |
1677 | BOOST_CHECK(cb3[0] == 1); | |
1678 | BOOST_CHECK(cb3[1] == 2); | |
1679 | BOOST_CHECK(it3 == cb3.end()); | |
1680 | BOOST_CHECK(cb4.size() == 0); | |
1681 | BOOST_CHECK(cb4.capacity() == 10); | |
1682 | BOOST_CHECK(it4 == cb4.end()); | |
1683 | ||
1684 | generic_test(cb1); | |
1685 | generic_test(cb2); | |
1686 | generic_test(cb3); | |
1687 | generic_test(cb4); | |
1688 | } | |
1689 | ||
1690 | void rerase_test() { | |
1691 | ||
1692 | CB_CONTAINER<MyInteger> cb1(4); | |
1693 | cb1.push_back(1); | |
1694 | cb1.push_back(2); | |
1695 | cb1.push_back(3); | |
1696 | CB_CONTAINER<MyInteger>::iterator it1 = cb1.rerase(cb1.begin() + 1); | |
1697 | ||
1698 | CB_CONTAINER<MyInteger> cb2(1, 1); | |
1699 | CB_CONTAINER<MyInteger>::iterator it2 = cb2.rerase(cb2.begin()); | |
1700 | ||
1701 | CB_CONTAINER<MyInteger> cb3(4); | |
1702 | cb3.push_back(1); | |
1703 | cb3.push_back(2); | |
1704 | cb3.push_back(3); | |
1705 | CB_CONTAINER<MyInteger>::iterator it3 = cb3.rerase(cb3.begin()); | |
1706 | ||
1707 | BOOST_CHECK(cb1.size() == 2); | |
1708 | BOOST_CHECK(cb1.capacity() == 4); | |
1709 | BOOST_CHECK(*it1 == 1); | |
1710 | BOOST_CHECK(cb1[0] == 1); | |
1711 | BOOST_CHECK(cb1[1] == 3); | |
1712 | BOOST_CHECK(cb2.size() == 0); | |
1713 | BOOST_CHECK(cb2.capacity() == 1); | |
1714 | BOOST_CHECK(it2 == cb2.begin()); | |
1715 | BOOST_CHECK(cb3.size() == 2); | |
1716 | BOOST_CHECK(cb3.capacity() == 4); | |
1717 | BOOST_CHECK(it3 == cb3.begin()); | |
1718 | BOOST_CHECK(*it3 == 2); | |
1719 | BOOST_CHECK(cb3[0] == 2); | |
1720 | BOOST_CHECK(cb3[1] == 3); | |
1721 | ||
1722 | generic_test(cb1); | |
1723 | generic_test(cb2); | |
1724 | generic_test(cb3); | |
1725 | } | |
1726 | ||
1727 | void rerase_range_test() { | |
1728 | ||
1729 | CB_CONTAINER<MyInteger> cb1(4); | |
1730 | cb1.push_back(1); | |
1731 | cb1.push_back(2); | |
1732 | cb1.push_back(3); | |
1733 | cb1.push_back(4); | |
1734 | CB_CONTAINER<MyInteger>::iterator it1 = cb1.rerase(cb1.begin() + 1, cb1.begin() + 3); | |
1735 | ||
1736 | CB_CONTAINER<MyInteger> cb2(4); | |
1737 | cb2.push_back(1); | |
1738 | cb2.push_back(2); | |
1739 | cb2.push_back(3); | |
1740 | cb2.push_back(4); | |
1741 | CB_CONTAINER<MyInteger>::iterator it2 = cb2.rerase(cb2.begin(), cb2.begin()); | |
1742 | ||
1743 | CB_CONTAINER<MyInteger> cb3(4); | |
1744 | cb3.push_back(1); | |
1745 | cb3.push_back(2); | |
1746 | cb3.push_back(3); | |
1747 | cb3.push_back(4); | |
1748 | CB_CONTAINER<MyInteger>::iterator it3 = cb3.rerase(cb3.begin(), cb3.begin() + 2); | |
1749 | ||
1750 | CB_CONTAINER<MyInteger> cb4(10, 1); | |
1751 | CB_CONTAINER<MyInteger>::iterator it4 = cb4.rerase(cb4.begin(), cb4.end()); | |
1752 | ||
1753 | BOOST_CHECK(cb1.size() == 2); | |
1754 | BOOST_CHECK(cb1.capacity() == 4); | |
1755 | BOOST_CHECK(cb1[0] == 1); | |
1756 | BOOST_CHECK(cb1[1] == 4); | |
1757 | BOOST_CHECK(*it1 == 1); | |
1758 | BOOST_CHECK(cb2.size() == 4); | |
1759 | BOOST_CHECK(cb2[0] == 1); | |
1760 | BOOST_CHECK(cb2[3] == 4); | |
1761 | BOOST_CHECK(*it2 == 1); | |
1762 | BOOST_CHECK(cb3.size() == 2); | |
1763 | BOOST_CHECK(cb3.capacity() == 4); | |
1764 | BOOST_CHECK(cb3[0] == 3); | |
1765 | BOOST_CHECK(cb3[1] == 4); | |
1766 | BOOST_CHECK(it3 == cb3.begin()); | |
1767 | BOOST_CHECK(cb4.size() == 0); | |
1768 | BOOST_CHECK(cb4.capacity() == 10); | |
1769 | BOOST_CHECK(it4 == cb4.begin()); | |
1770 | ||
1771 | generic_test(cb1); | |
1772 | generic_test(cb2); | |
1773 | generic_test(cb3); | |
1774 | generic_test(cb4); | |
1775 | } | |
1776 | ||
1777 | void clear_test() { | |
1778 | ||
1779 | CB_CONTAINER<MyInteger> cb(4); | |
1780 | cb.push_back(1); | |
1781 | cb.push_back(2); | |
1782 | cb.push_back(3); | |
1783 | cb.push_back(4); | |
1784 | cb.clear(); | |
1785 | ||
1786 | BOOST_CHECK(cb.empty()); | |
1787 | ||
1788 | generic_test(cb); | |
1789 | } | |
1790 | ||
1791 | void equality_test() { | |
1792 | ||
1793 | CB_CONTAINER<MyInteger> cb1(4); | |
1794 | cb1.push_back(1); | |
1795 | cb1.push_back(2); | |
1796 | cb1.push_back(3); | |
1797 | cb1.push_back(4); | |
1798 | CB_CONTAINER<MyInteger> cb2(10); | |
1799 | cb2.push_back(1); | |
1800 | cb2.push_back(2); | |
1801 | cb2.push_back(3); | |
1802 | cb2.push_back(4); | |
1803 | ||
1804 | BOOST_CHECK(cb1 == cb2); | |
1805 | BOOST_CHECK(!(cb2 != cb1)); | |
1806 | ||
1807 | generic_test(cb1); | |
1808 | generic_test(cb2); | |
1809 | } | |
1810 | ||
1811 | void lexicographical_comparison_test() { | |
1812 | ||
1813 | CB_CONTAINER<char> cb1(10); | |
1814 | cb1.push_back('a'); | |
1815 | cb1.push_back('d'); | |
1816 | cb1.push_back('a'); | |
1817 | cb1.push_back('m'); | |
1818 | CB_CONTAINER<char> cb2(5); | |
1819 | cb2.push_back('j'); | |
1820 | cb2.push_back('o'); | |
1821 | cb2.push_back('h'); | |
1822 | cb2.push_back('n'); | |
1823 | ||
1824 | BOOST_CHECK(cb2 > cb1); | |
1825 | BOOST_CHECK(cb1 < cb2); | |
1826 | } | |
1827 | ||
1828 | void assign_range_test() { | |
1829 | ||
1830 | vector<int> v; | |
1831 | v.push_back(11); | |
1832 | v.push_back(12); | |
1833 | v.push_back(13); | |
1834 | CB_CONTAINER<MyInteger> cb1(4); | |
1835 | cb1.push_back(1); | |
1836 | cb1.push_back(2); | |
1837 | cb1.push_back(3); | |
1838 | cb1.assign(v.begin() + 1, v.end()); | |
1839 | CB_CONTAINER<MyInteger> cb2(2); | |
1840 | cb2.push_back(1); | |
1841 | cb2.push_back(2); | |
1842 | cb2.assign(v.begin(), v.end()); | |
1843 | ||
1844 | BOOST_CHECK(cb1.capacity() == 2); | |
1845 | BOOST_CHECK(cb1[0] == 12); | |
1846 | BOOST_CHECK(cb1[1] == 13); | |
1847 | BOOST_CHECK(cb2.full()); | |
1848 | BOOST_CHECK(cb2.capacity() == 3); | |
1849 | BOOST_CHECK(cb2[0] == 11); | |
1850 | BOOST_CHECK(cb2[1] == 12); | |
1851 | BOOST_CHECK(cb2[2] == 13); | |
1852 | BOOST_CHECK(cb2.size() == (size_t)distance(v.begin(), v.end())); | |
1853 | ||
1854 | generic_test(cb1); | |
1855 | generic_test(cb2); | |
1856 | } | |
1857 | ||
1858 | // test of the example (introduced in the documentation) | |
1859 | void example_test() { | |
1860 | ||
1861 | CB_CONTAINER<int> cb1(3); | |
1862 | cb1.push_back(1); | |
1863 | cb1.push_back(2); | |
1864 | ||
1865 | BOOST_CHECK(cb1[0] == 1); | |
1866 | BOOST_CHECK(cb1[1] == 2); | |
1867 | BOOST_CHECK(!cb1.full()); | |
1868 | BOOST_CHECK(cb1.size() == 2); | |
1869 | BOOST_CHECK(cb1.capacity() == 3); | |
1870 | ||
1871 | cb1.push_back(3); | |
1872 | cb1.push_back(4); | |
1873 | int sum = accumulate(cb1.begin(), cb1.end(), 0); | |
1874 | ||
1875 | BOOST_CHECK(cb1[0] == 2); | |
1876 | BOOST_CHECK(cb1[1] == 3); | |
1877 | BOOST_CHECK(cb1[2] == 4); | |
1878 | BOOST_CHECK(*cb1.begin() == 2); | |
1879 | BOOST_CHECK(cb1.front() == 2); | |
1880 | BOOST_CHECK(cb1.back() == 4); | |
1881 | BOOST_CHECK(sum == 9); | |
1882 | BOOST_CHECK(cb1.full()); | |
1883 | BOOST_CHECK(cb1.size() == 3); | |
1884 | BOOST_CHECK(cb1.capacity() == 3); | |
1885 | ||
1886 | CB_CONTAINER<int> cb2(5, 1); | |
1887 | cb2.insert(cb2.begin(), 2); | |
1888 | ||
1889 | BOOST_CHECK(cb2[0] == 1); | |
1890 | BOOST_CHECK(cb2[1] == 1); | |
1891 | BOOST_CHECK(cb2[2] == 1); | |
1892 | BOOST_CHECK(cb2[3] == 1); | |
1893 | BOOST_CHECK(cb2[4] == 1); | |
1894 | ||
1895 | vector<int> v; | |
1896 | v.push_back(100); | |
1897 | v.push_back(200); | |
1898 | v.push_back(300); | |
1899 | cb2.insert(cb2.begin() + 1, v.begin(), v.end()); | |
1900 | ||
1901 | BOOST_CHECK(cb2[0] == 300); | |
1902 | BOOST_CHECK(cb2[1] == 1); | |
1903 | BOOST_CHECK(cb2[2] == 1); | |
1904 | BOOST_CHECK(cb2[3] == 1); | |
1905 | BOOST_CHECK(cb2[4] == 1); | |
1906 | ||
1907 | CB_CONTAINER<int> cb3(3); | |
1908 | cb3.push_back(1); | |
1909 | cb3.push_back(2); | |
1910 | cb3.push_back(3); | |
1911 | ||
1912 | BOOST_CHECK(cb3[0] == 1); | |
1913 | BOOST_CHECK(cb3[1] == 2); | |
1914 | BOOST_CHECK(cb3[2] == 3); | |
1915 | ||
1916 | cb3.push_back(4); | |
1917 | cb3.push_back(5); | |
1918 | ||
1919 | BOOST_CHECK(cb3[0] == 3); | |
1920 | BOOST_CHECK(cb3[1] == 4); | |
1921 | BOOST_CHECK(cb3[2] == 5); | |
1922 | ||
1923 | cb3.pop_back(); | |
1924 | cb3.pop_front(); | |
1925 | ||
1926 | BOOST_CHECK(cb3[0] == 4); | |
1927 | } | |
1928 | ||
1929 | void element_destruction_test() { | |
1930 | ||
1931 | CB_CONTAINER<InstanceCounter> cb(5); | |
1932 | cb.push_back(InstanceCounter()); | |
1933 | cb.push_back(InstanceCounter()); | |
1934 | cb.push_back(InstanceCounter()); | |
1935 | int prevCount = InstanceCounter::count(); | |
1936 | cb.clear(); | |
1937 | ||
1938 | BOOST_CHECK(cb.empty()); | |
1939 | BOOST_CHECK(prevCount == 3); | |
1940 | BOOST_CHECK(InstanceCounter::count() == 0); | |
1941 | } | |
1942 | ||
1943 | void const_methods_test() { | |
1944 | ||
1945 | vector<int> v; | |
1946 | v.push_back(1); | |
1947 | v.push_back(2); | |
1948 | v.push_back(3); | |
1949 | v.push_back(4); | |
1950 | v.push_back(5); | |
1951 | const CB_CONTAINER<MyInteger> cb(5, v.begin(), v.end()); | |
1952 | ||
1953 | BOOST_CHECK(*cb.begin() == 1); | |
1954 | BOOST_CHECK(*(cb.end() - 1) == 5); | |
1955 | BOOST_CHECK(*cb.rbegin() == 5); | |
1956 | BOOST_CHECK(*(cb.rend() - 1) == 1); | |
1957 | BOOST_CHECK(cb[0] == 1); | |
1958 | BOOST_CHECK(cb.at(1) == 2); | |
1959 | BOOST_CHECK(cb.front() == 1); | |
1960 | BOOST_CHECK(cb.back() == 5); | |
1961 | } | |
1962 | ||
1963 | void rotate_test() { | |
1964 | ||
1965 | CB_CONTAINER<MyInteger> cb1(10); | |
1966 | cb1.push_back(1); | |
1967 | cb1.push_back(2); | |
1968 | cb1.push_back(3); | |
1969 | cb1.push_back(4); | |
1970 | cb1.push_back(5); | |
1971 | cb1.push_back(6); | |
1972 | cb1.push_back(7); | |
1973 | CB_CONTAINER<MyInteger> cb2 = cb1; | |
1974 | CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 2; | |
1975 | int v1_0 = *it1; | |
1976 | int v1_1 = *(it1 + 1); | |
1977 | int v1_2 = *(it1 + 2); | |
1978 | int v1_3 = *(it1 + 3); | |
1979 | int v1_4 = *(it1 + 4); | |
1980 | int v1_r1 = *(it1 - 1); | |
1981 | int v1_r2 = *(it1 - 2); | |
1982 | cb1.rotate(it1); | |
1983 | rotate(cb2.begin(), cb2.begin() + 2, cb2.end()); | |
1984 | ||
1985 | CB_CONTAINER<MyInteger> cb3(7); | |
1986 | cb3.push_back(1); | |
1987 | cb3.push_back(2); | |
1988 | cb3.push_back(3); | |
1989 | cb3.push_back(4); | |
1990 | cb3.push_back(5); | |
1991 | cb3.push_back(6); | |
1992 | cb3.push_back(7); | |
1993 | cb3.push_back(8); | |
1994 | cb3.push_back(9); | |
1995 | CB_CONTAINER<MyInteger> cb4 = cb3; | |
1996 | CB_CONTAINER<MyInteger>::iterator it2 = cb3.begin() + 1; | |
1997 | int v2_0 = *it2; | |
1998 | int v2_1 = *(it2 + 1); | |
1999 | int v2_2 = *(it2 + 2); | |
2000 | int v2_3 = *(it2 + 3); | |
2001 | int v2_4 = *(it2 + 4); | |
2002 | int v2_5 = *(it2 + 5); | |
2003 | int v2_r1 = *(it2 - 1); | |
2004 | cb3.rotate(it2); | |
2005 | rotate(cb4.begin(), cb4.begin() + 1, cb4.end()); | |
2006 | ||
2007 | CB_CONTAINER<MyInteger> cb5(10); | |
2008 | cb5.push_back(1); | |
2009 | cb5.push_back(2); | |
2010 | cb5.push_back(3); | |
2011 | cb5.push_back(4); | |
2012 | cb5.push_back(5); | |
2013 | cb5.push_back(6); | |
2014 | cb5.push_back(7); | |
2015 | CB_CONTAINER<MyInteger> cb6 = cb5; | |
2016 | CB_CONTAINER<MyInteger>::iterator it3 = cb5.begin() + 5; | |
2017 | int v3_0 = *it3; | |
2018 | int v3_1 = *(it3 + 1); | |
2019 | int v3_r1 = *(it3 - 1); | |
2020 | int v3_r2 = *(it3 - 2); | |
2021 | int v3_r3 = *(it3 - 3); | |
2022 | int v3_r4 = *(it3 - 4); | |
2023 | int v3_r5 = *(it3 - 5); | |
2024 | cb5.rotate(it3); | |
2025 | rotate(cb6.begin(), cb6.begin() + 5, cb6.end()); | |
2026 | ||
2027 | BOOST_CHECK(!cb1.full()); | |
2028 | BOOST_CHECK(cb1 == cb2); | |
2029 | BOOST_CHECK(v1_0 == *it1); | |
2030 | BOOST_CHECK(v1_1 == *(it1 + 1)); | |
2031 | BOOST_CHECK(v1_2 == *(it1 + 2)); | |
2032 | BOOST_CHECK(v1_3 == *(it1 + 3)); | |
2033 | BOOST_CHECK(v1_4 == *(it1 + 4)); | |
2034 | BOOST_CHECK(v1_r1 == *(it1 + 6)); | |
2035 | BOOST_CHECK(v1_r2 == *(it1 + 5)); | |
2036 | BOOST_CHECK(cb1.begin() == it1); | |
2037 | BOOST_CHECK(v1_0 == cb1[0]); | |
2038 | BOOST_CHECK(v1_1 == cb1[1]); | |
2039 | BOOST_CHECK(v1_2 == cb1[2]); | |
2040 | BOOST_CHECK(v1_3 == cb1[3]); | |
2041 | BOOST_CHECK(v1_4 == cb1[4]); | |
2042 | BOOST_CHECK(v1_r1 == cb1[6]); | |
2043 | BOOST_CHECK(v1_r2 == cb1[5]); | |
2044 | BOOST_CHECK(cb3.full()); | |
2045 | BOOST_CHECK(cb3 == cb4); | |
2046 | BOOST_CHECK(v2_0 == *it2); | |
2047 | BOOST_CHECK(v2_1 == *(it2 + 1)); | |
2048 | BOOST_CHECK(v2_2 == *(it2 + 2)); | |
2049 | BOOST_CHECK(v2_3 == *(it2 + 3)); | |
2050 | BOOST_CHECK(v2_4 == *(it2 + 4)); | |
2051 | BOOST_CHECK(v2_5 == *(it2 + 5)); | |
2052 | BOOST_CHECK(v2_r1 == *(it2 + 6)); | |
2053 | BOOST_CHECK(cb3.begin() == it2); | |
2054 | BOOST_CHECK(v2_0 == cb3[0]); | |
2055 | BOOST_CHECK(v2_1 == cb3[1]); | |
2056 | BOOST_CHECK(v2_2 == cb3[2]); | |
2057 | BOOST_CHECK(v2_3 == cb3[3]); | |
2058 | BOOST_CHECK(v2_4 == cb3[4]); | |
2059 | BOOST_CHECK(v2_5 == cb3[5]); | |
2060 | BOOST_CHECK(v2_r1 == cb3[6]); | |
2061 | BOOST_CHECK(!cb5.full()); | |
2062 | BOOST_CHECK(cb5 == cb6); | |
2063 | BOOST_CHECK(v3_0 == cb5[0]); | |
2064 | BOOST_CHECK(v3_1 == cb5[1]); | |
2065 | BOOST_CHECK(v3_r1 == cb5[6]); | |
2066 | BOOST_CHECK(v3_r2 == cb5[5]); | |
2067 | BOOST_CHECK(v3_r3 == cb5[4]); | |
2068 | BOOST_CHECK(v3_r4 == cb5[3]); | |
2069 | BOOST_CHECK(v3_r5 == cb5[2]); | |
2070 | ||
2071 | generic_test(cb1); | |
2072 | generic_test(cb2); | |
2073 | generic_test(cb3); | |
2074 | generic_test(cb4); | |
2075 | generic_test(cb5); | |
2076 | generic_test(cb6); | |
2077 | } | |
2078 | ||
2079 | int MyInteger::ms_exception_trigger = 0; | |
2080 | int InstanceCounter::ms_count = 0; | |
2081 | ||
2082 | void move_container_on_cpp11() { | |
2083 | #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES | |
2084 | CB_CONTAINER<MyInteger> cb1(10); | |
2085 | cb1.push_back(1); | |
2086 | cb1.push_back(2); | |
2087 | cb1.push_back(3); | |
2088 | cb1.push_back(4); | |
2089 | cb1.push_back(5); | |
2090 | cb1.push_back(6); | |
2091 | ||
2092 | // Checking move constructor | |
2093 | CB_CONTAINER<MyInteger> cb2(static_cast<CB_CONTAINER<MyInteger>&& >(cb1)); | |
2094 | CB_CONTAINER<MyInteger>::iterator it2 = cb2.begin() + 1; | |
2095 | ||
2096 | BOOST_CHECK(cb1.empty()); | |
2097 | BOOST_CHECK(!cb2.empty()); | |
2098 | BOOST_CHECK(it2[0] == 2); | |
2099 | BOOST_CHECK(it2[-1] == 1); | |
2100 | BOOST_CHECK(it2[2] == 4); | |
2101 | ||
2102 | // Checking move assignment | |
2103 | cb1 = static_cast<CB_CONTAINER<MyInteger>&& >(cb2); | |
2104 | CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1; | |
2105 | ||
2106 | BOOST_CHECK(!cb1.empty()); | |
2107 | BOOST_CHECK(cb2.empty()); | |
2108 | BOOST_CHECK(it1[0] == 2); | |
2109 | BOOST_CHECK(it1[-1] == 1); | |
2110 | BOOST_CHECK(it1[2] == 4); | |
2111 | #endif | |
2112 | } | |
2113 | ||
2114 | ||
2115 | struct noncopyable_movable_except_t | |
2116 | { | |
2117 | private: | |
2118 | BOOST_MOVABLE_BUT_NOT_COPYABLE(noncopyable_movable_except_t) | |
2119 | bool is_moved_; | |
2120 | int value_; | |
2121 | public: | |
2122 | static int next_value; | |
2123 | ||
2124 | explicit noncopyable_movable_except_t() | |
2125 | : is_moved_(false) | |
2126 | , value_(next_value ++) | |
2127 | {} | |
2128 | ||
2129 | noncopyable_movable_except_t(BOOST_RV_REF(noncopyable_movable_except_t) x) { | |
2130 | is_moved_ = x.is_moved_; | |
2131 | value_ = x.value_; | |
2132 | x.is_moved_ = true; | |
2133 | } | |
2134 | ||
2135 | noncopyable_movable_except_t& operator=(BOOST_RV_REF(noncopyable_movable_except_t) x) { | |
2136 | is_moved_ = x.is_moved_; | |
2137 | value_ = x.value_; | |
2138 | x.is_moved_ = true; | |
2139 | return *this; | |
2140 | } | |
2141 | ||
2142 | bool is_moved() const { | |
2143 | return is_moved_; | |
2144 | } | |
2145 | ||
2146 | int value() const { | |
2147 | return value_; | |
2148 | } | |
2149 | ||
2150 | void reinit() { is_moved_ = false; value_ = next_value ++; } | |
2151 | }; | |
2152 | ||
2153 | struct noncopyable_movable_noexcept_t | |
2154 | { | |
2155 | private: | |
2156 | BOOST_MOVABLE_BUT_NOT_COPYABLE(noncopyable_movable_noexcept_t) | |
2157 | bool is_moved_; | |
2158 | int value_; | |
2159 | public: | |
2160 | static int next_value; | |
2161 | ||
2162 | explicit noncopyable_movable_noexcept_t() | |
2163 | : is_moved_(false) | |
2164 | , value_(next_value ++) | |
2165 | {} | |
2166 | ||
2167 | noncopyable_movable_noexcept_t(BOOST_RV_REF(noncopyable_movable_noexcept_t) x) BOOST_NOEXCEPT { | |
2168 | is_moved_ = x.is_moved_; | |
2169 | value_ = x.value_; | |
2170 | x.is_moved_ = true; | |
2171 | } | |
2172 | ||
2173 | noncopyable_movable_noexcept_t& operator=(BOOST_RV_REF(noncopyable_movable_noexcept_t) x) BOOST_NOEXCEPT { | |
2174 | is_moved_ = x.is_moved_; | |
2175 | value_ = x.value_; | |
2176 | x.is_moved_ = true; | |
2177 | return *this; | |
2178 | } | |
2179 | ||
2180 | bool is_moved() const { | |
2181 | return is_moved_; | |
2182 | } | |
2183 | ||
2184 | int value() const { | |
2185 | return value_; | |
2186 | } | |
2187 | ||
2188 | void reinit() { is_moved_ = false; value_ = next_value ++; } | |
2189 | }; | |
2190 | ||
2191 | #ifdef BOOST_NO_CXX11_NOEXCEPT | |
2192 | namespace boost { | |
2193 | template <> | |
2194 | struct is_nothrow_move_constructible<noncopyable_movable_noexcept_t> | |
2195 | : boost::true_type | |
2196 | {}; | |
2197 | } | |
2198 | #endif | |
2199 | ||
2200 | int noncopyable_movable_noexcept_t::next_value = 1; | |
2201 | int noncopyable_movable_except_t::next_value = 1; | |
2202 | ||
2203 | template <class T> | |
2204 | void move_container_values_impl() { | |
2205 | typedef T noncopyable_movable_test_t; | |
2206 | noncopyable_movable_test_t::next_value = 1; | |
2207 | ||
2208 | CB_CONTAINER<noncopyable_movable_test_t> cb1(40); | |
2209 | noncopyable_movable_test_t var; | |
2210 | cb1.push_back(boost::move(var)); | |
2211 | BOOST_CHECK(!cb1.back().is_moved()); | |
2212 | BOOST_CHECK(cb1.back().value() == 1); | |
2213 | BOOST_CHECK(var.is_moved()); | |
2214 | BOOST_CHECK(cb1.size() == 1); | |
2215 | ||
2216 | var.reinit(); | |
2217 | cb1.push_front(boost::move(var)); | |
2218 | BOOST_CHECK(!cb1.front().is_moved()); | |
2219 | BOOST_CHECK(cb1.front().value() == 2); | |
2220 | BOOST_CHECK(var.is_moved()); | |
2221 | BOOST_CHECK(cb1.size() == 2); | |
2222 | ||
2223 | cb1.push_back(); | |
2224 | BOOST_CHECK(!cb1.back().is_moved()); | |
2225 | BOOST_CHECK(cb1.back().value() == 3); | |
2226 | BOOST_CHECK(cb1.size() == 3); | |
2227 | ||
2228 | cb1.push_front(); | |
2229 | BOOST_CHECK(!cb1.front().is_moved()); | |
2230 | BOOST_CHECK(cb1.front().value() == 4); | |
2231 | BOOST_CHECK(cb1.size() == 4); | |
2232 | ||
2233 | cb1.insert(cb1.begin()); | |
2234 | BOOST_CHECK(!cb1.front().is_moved()); | |
2235 | BOOST_CHECK(cb1.front().value() == 5); | |
2236 | BOOST_CHECK(cb1.size() == 5); | |
2237 | ||
2238 | var.reinit(); | |
2239 | cb1.insert(cb1.begin(), boost::move(var)); | |
2240 | BOOST_CHECK(!cb1.front().is_moved()); | |
2241 | BOOST_CHECK(cb1.front().value() == 6); | |
2242 | BOOST_CHECK(cb1.size() == 6); | |
2243 | ||
2244 | cb1.rinsert(cb1.begin()); | |
2245 | BOOST_CHECK(!cb1.front().is_moved()); | |
2246 | BOOST_CHECK(cb1.front().value() == 7); | |
2247 | BOOST_CHECK(cb1.size() == 7); | |
2248 | ||
2249 | var.reinit(); | |
2250 | cb1.rinsert(cb1.begin(), boost::move(var)); | |
2251 | BOOST_CHECK(!cb1.front().is_moved()); | |
2252 | BOOST_CHECK(cb1.front().value() == 8); | |
2253 | BOOST_CHECK(cb1.size() == 8); | |
2254 | ||
2255 | ||
2256 | BOOST_CHECK(cb1[0].value() == 8); | |
2257 | BOOST_CHECK(cb1[1].value() == 7); | |
2258 | BOOST_CHECK(cb1[2].value() == 6); | |
2259 | BOOST_CHECK(cb1[3].value() == 5); | |
2260 | BOOST_CHECK(cb1[4].value() == 4); | |
2261 | BOOST_CHECK(cb1[5].value() == 2); | |
2262 | BOOST_CHECK(cb1[6].value() == 1); | |
2263 | BOOST_CHECK(cb1[7].value() == 3); | |
2264 | cb1.rotate(cb1.begin() + 2); | |
2265 | BOOST_CHECK(cb1[0].value() == 6); | |
2266 | BOOST_CHECK(cb1[1].value() == 5); | |
2267 | BOOST_CHECK(cb1[2].value() == 4); | |
2268 | BOOST_CHECK(cb1[3].value() == 2); | |
2269 | BOOST_CHECK(cb1[4].value() == 1); | |
2270 | BOOST_CHECK(cb1[5].value() == 3); | |
2271 | BOOST_CHECK(cb1[6].value() == 8); | |
2272 | BOOST_CHECK(cb1[7].value() == 7); | |
2273 | ||
2274 | BOOST_CHECK(!cb1[0].is_moved()); | |
2275 | BOOST_CHECK(!cb1[1].is_moved()); | |
2276 | BOOST_CHECK(!cb1[2].is_moved()); | |
2277 | BOOST_CHECK(!cb1[3].is_moved()); | |
2278 | BOOST_CHECK(!cb1[4].is_moved()); | |
2279 | BOOST_CHECK(!cb1[5].is_moved()); | |
2280 | BOOST_CHECK(!cb1[6].is_moved()); | |
2281 | BOOST_CHECK(!cb1[7].is_moved()); | |
2282 | ||
2283 | cb1.linearize(); | |
2284 | BOOST_CHECK(!cb1[0].is_moved()); | |
2285 | BOOST_CHECK(!cb1[1].is_moved()); | |
2286 | BOOST_CHECK(!cb1[2].is_moved()); | |
2287 | BOOST_CHECK(!cb1[3].is_moved()); | |
2288 | BOOST_CHECK(!cb1[4].is_moved()); | |
2289 | BOOST_CHECK(!cb1[5].is_moved()); | |
2290 | BOOST_CHECK(!cb1[6].is_moved()); | |
2291 | BOOST_CHECK(!cb1[7].is_moved()); | |
2292 | BOOST_CHECK(cb1[0].value() == 6); | |
2293 | BOOST_CHECK(cb1[1].value() == 5); | |
2294 | BOOST_CHECK(cb1[2].value() == 4); | |
2295 | BOOST_CHECK(cb1[3].value() == 2); | |
2296 | BOOST_CHECK(cb1[4].value() == 1); | |
2297 | BOOST_CHECK(cb1[5].value() == 3); | |
2298 | BOOST_CHECK(cb1[6].value() == 8); | |
2299 | BOOST_CHECK(cb1[7].value() == 7); | |
2300 | ||
2301 | cb1.erase(cb1.begin()); | |
2302 | BOOST_CHECK(!cb1[0].is_moved()); | |
2303 | BOOST_CHECK(!cb1[1].is_moved()); | |
2304 | BOOST_CHECK(!cb1[2].is_moved()); | |
2305 | BOOST_CHECK(!cb1[3].is_moved()); | |
2306 | BOOST_CHECK(!cb1[4].is_moved()); | |
2307 | BOOST_CHECK(!cb1[5].is_moved()); | |
2308 | BOOST_CHECK(!cb1[6].is_moved()); | |
2309 | BOOST_CHECK(cb1[0].value() == 5); | |
2310 | BOOST_CHECK(cb1[1].value() == 4); | |
2311 | BOOST_CHECK(cb1[2].value() == 2); | |
2312 | BOOST_CHECK(cb1[3].value() == 1); | |
2313 | BOOST_CHECK(cb1[4].value() == 3); | |
2314 | BOOST_CHECK(cb1[5].value() == 8); | |
2315 | BOOST_CHECK(cb1[6].value() == 7); | |
2316 | ||
2317 | cb1.rerase(cb1.begin()); | |
2318 | BOOST_CHECK(!cb1[0].is_moved()); | |
2319 | BOOST_CHECK(!cb1[1].is_moved()); | |
2320 | BOOST_CHECK(!cb1[2].is_moved()); | |
2321 | BOOST_CHECK(!cb1[3].is_moved()); | |
2322 | BOOST_CHECK(!cb1[4].is_moved()); | |
2323 | BOOST_CHECK(!cb1[5].is_moved()); | |
2324 | BOOST_CHECK(cb1[0].value() == 4); | |
2325 | BOOST_CHECK(cb1[1].value() == 2); | |
2326 | BOOST_CHECK(cb1[2].value() == 1); | |
2327 | BOOST_CHECK(cb1[3].value() == 3); | |
2328 | BOOST_CHECK(cb1[4].value() == 8); | |
2329 | BOOST_CHECK(cb1[5].value() == 7); | |
2330 | ||
2331 | cb1.erase(cb1.begin(), cb1.begin() + 1); | |
2332 | BOOST_CHECK(!cb1[0].is_moved()); | |
2333 | BOOST_CHECK(!cb1[1].is_moved()); | |
2334 | BOOST_CHECK(!cb1[2].is_moved()); | |
2335 | BOOST_CHECK(!cb1[3].is_moved()); | |
2336 | BOOST_CHECK(!cb1[4].is_moved()); | |
2337 | BOOST_CHECK(cb1[0].value() == 2); | |
2338 | BOOST_CHECK(cb1[1].value() == 1); | |
2339 | BOOST_CHECK(cb1[2].value() == 3); | |
2340 | BOOST_CHECK(cb1[3].value() == 8); | |
2341 | BOOST_CHECK(cb1[4].value() == 7); | |
2342 | ||
2343 | cb1.rerase(cb1.begin(), cb1.begin() + 1); | |
2344 | BOOST_CHECK(!cb1[0].is_moved()); | |
2345 | BOOST_CHECK(!cb1[1].is_moved()); | |
2346 | BOOST_CHECK(!cb1[2].is_moved()); | |
2347 | BOOST_CHECK(!cb1[3].is_moved()); | |
2348 | BOOST_CHECK(cb1[0].value() == 1); | |
2349 | BOOST_CHECK(cb1[1].value() == 3); | |
2350 | BOOST_CHECK(cb1[2].value() == 8); | |
2351 | BOOST_CHECK(cb1[3].value() == 7); | |
2352 | } | |
2353 | ||
2354 | void move_container_values_noexcept() { | |
2355 | move_container_values_impl<noncopyable_movable_noexcept_t>(); | |
2356 | ||
2357 | typedef noncopyable_movable_noexcept_t noncopyable_movable_test_t; | |
2358 | noncopyable_movable_test_t::next_value = 1; | |
2359 | CB_CONTAINER<noncopyable_movable_test_t> cb1(40); | |
2360 | cb1.push_back(); | |
2361 | cb1.push_back(); | |
2362 | cb1.push_back(); | |
2363 | cb1.push_back(); | |
2364 | cb1.push_back(); | |
2365 | cb1.push_back(); | |
2366 | cb1.push_back(); | |
2367 | cb1.push_back(); | |
2368 | ||
2369 | cb1.set_capacity(100); | |
2370 | BOOST_CHECK(!cb1[0].is_moved()); | |
2371 | BOOST_CHECK(!cb1[1].is_moved()); | |
2372 | BOOST_CHECK(!cb1[2].is_moved()); | |
2373 | BOOST_CHECK(!cb1[3].is_moved()); | |
2374 | BOOST_CHECK(!cb1[4].is_moved()); | |
2375 | BOOST_CHECK(!cb1[5].is_moved()); | |
2376 | BOOST_CHECK(!cb1[6].is_moved()); | |
2377 | BOOST_CHECK(!cb1[7].is_moved()); | |
2378 | BOOST_CHECK(cb1[0].value() == 1); | |
2379 | BOOST_CHECK(cb1[1].value() == 2); | |
2380 | BOOST_CHECK(cb1[2].value() == 3); | |
2381 | BOOST_CHECK(cb1[3].value() == 4); | |
2382 | BOOST_CHECK(cb1[4].value() == 5); | |
2383 | BOOST_CHECK(cb1[5].value() == 6); | |
2384 | BOOST_CHECK(cb1[6].value() == 7); | |
2385 | BOOST_CHECK(cb1[7].value() == 8); | |
2386 | ||
2387 | cb1.rset_capacity(101); | |
2388 | BOOST_CHECK(!cb1[0].is_moved()); | |
2389 | BOOST_CHECK(!cb1[1].is_moved()); | |
2390 | BOOST_CHECK(!cb1[2].is_moved()); | |
2391 | BOOST_CHECK(!cb1[3].is_moved()); | |
2392 | BOOST_CHECK(!cb1[4].is_moved()); | |
2393 | BOOST_CHECK(!cb1[5].is_moved()); | |
2394 | BOOST_CHECK(!cb1[6].is_moved()); | |
2395 | BOOST_CHECK(!cb1[7].is_moved()); | |
2396 | BOOST_CHECK(cb1[0].value() == 1); | |
2397 | BOOST_CHECK(cb1[1].value() == 2); | |
2398 | BOOST_CHECK(cb1[2].value() == 3); | |
2399 | BOOST_CHECK(cb1[3].value() == 4); | |
2400 | BOOST_CHECK(cb1[4].value() == 5); | |
2401 | BOOST_CHECK(cb1[5].value() == 6); | |
2402 | BOOST_CHECK(cb1[6].value() == 7); | |
2403 | BOOST_CHECK(cb1[7].value() == 8); | |
2404 | ||
2405 | cb1.set_capacity(2); | |
2406 | BOOST_CHECK(!cb1[0].is_moved()); | |
2407 | BOOST_CHECK(!cb1[1].is_moved()); | |
2408 | BOOST_CHECK(cb1[0].value() == 1); | |
2409 | BOOST_CHECK(cb1[1].value() == 2); | |
2410 | ||
2411 | cb1.rset_capacity(1); | |
2412 | BOOST_CHECK(!cb1[0].is_moved()); | |
2413 | BOOST_CHECK(cb1[0].value() == 2); | |
2414 | } | |
2415 | ||
2416 | void check_containers_exception_specifications() { | |
2417 | #ifndef BOOST_NO_CXX11_NOEXCEPT | |
2418 | #ifndef BOOST_CLANG | |
2419 | // Clang has an error in __has_nothrow_constructor implementation: | |
2420 | // http://llvm.org/bugs/show_bug.cgi?id=16627 | |
2421 | BOOST_CHECK(boost::has_nothrow_constructor<CB_CONTAINER<int> >::value); | |
2422 | #endif | |
2423 | ||
2424 | #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES | |
2425 | BOOST_CHECK(boost::is_nothrow_move_assignable<CB_CONTAINER<int> >::value); | |
2426 | BOOST_CHECK(boost::is_nothrow_move_constructible<CB_CONTAINER<int> >::value); | |
2427 | #endif | |
2428 | #endif // BOOST_NO_CXX11_NOEXCEPT | |
2429 | } | |
2430 | ||
2431 | // add common tests into a test suite | |
2432 | void add_common_tests(test_suite* tests) { | |
2433 | tests->add(BOOST_TEST_CASE(&basic_test)); | |
2434 | tests->add(BOOST_TEST_CASE(&constructor_and_element_access_test)); | |
2435 | tests->add(BOOST_TEST_CASE(&size_test)); | |
2436 | tests->add(BOOST_TEST_CASE(&allocator_test)); | |
2437 | tests->add(BOOST_TEST_CASE(&begin_and_end_test)); | |
2438 | tests->add(BOOST_TEST_CASE(&rbegin_and_rend_test)); | |
2439 | tests->add(BOOST_TEST_CASE(&element_access_and_insert_test)); | |
2440 | tests->add(BOOST_TEST_CASE(&at_test)); | |
2441 | tests->add(BOOST_TEST_CASE(&front_and_back_test)); | |
2442 | tests->add(BOOST_TEST_CASE(&linearize_test)); | |
2443 | tests->add(BOOST_TEST_CASE(&array_range_test)); | |
2444 | tests->add(BOOST_TEST_CASE(&capacity_and_reserve_test)); | |
2445 | tests->add(BOOST_TEST_CASE(&full_and_empty_test)); | |
2446 | tests->add(BOOST_TEST_CASE(&set_capacity_test)); | |
2447 | tests->add(BOOST_TEST_CASE(&rset_capacity_test)); | |
2448 | tests->add(BOOST_TEST_CASE(&resize_test)); | |
2449 | tests->add(BOOST_TEST_CASE(&rresize_test)); | |
2450 | tests->add(BOOST_TEST_CASE(&constructor_test)); | |
2451 | tests->add(BOOST_TEST_CASE(&assign_test)); | |
2452 | tests->add(BOOST_TEST_CASE(©_constructor_and_assign_test)); | |
2453 | tests->add(BOOST_TEST_CASE(&swap_test)); | |
2454 | tests->add(BOOST_TEST_CASE(&push_back_test)); | |
2455 | tests->add(BOOST_TEST_CASE(&pop_back_test)); | |
2456 | tests->add(BOOST_TEST_CASE(&insert_test)); | |
2457 | tests->add(BOOST_TEST_CASE(&insert_n_test)); | |
2458 | tests->add(BOOST_TEST_CASE(&insert_range_test)); | |
2459 | tests->add(BOOST_TEST_CASE(&push_front_test)); | |
2460 | tests->add(BOOST_TEST_CASE(&pop_front_test)); | |
2461 | tests->add(BOOST_TEST_CASE(&rinsert_test)); | |
2462 | tests->add(BOOST_TEST_CASE(&rinsert_n_test)); | |
2463 | tests->add(BOOST_TEST_CASE(&rinsert_range_test)); | |
2464 | tests->add(BOOST_TEST_CASE(&erase_test)); | |
2465 | tests->add(BOOST_TEST_CASE(&erase_range_test)); | |
2466 | tests->add(BOOST_TEST_CASE(&rerase_test)); | |
2467 | tests->add(BOOST_TEST_CASE(&rerase_range_test)); | |
2468 | tests->add(BOOST_TEST_CASE(&clear_test)); | |
2469 | tests->add(BOOST_TEST_CASE(&equality_test)); | |
2470 | tests->add(BOOST_TEST_CASE(&lexicographical_comparison_test)); | |
2471 | tests->add(BOOST_TEST_CASE(&assign_range_test)); | |
2472 | tests->add(BOOST_TEST_CASE(&example_test)); | |
2473 | tests->add(BOOST_TEST_CASE(&element_destruction_test)); | |
2474 | tests->add(BOOST_TEST_CASE(&const_methods_test)); | |
2475 | tests->add(BOOST_TEST_CASE(&rotate_test)); | |
2476 | tests->add(BOOST_TEST_CASE(&move_container_on_cpp11)); | |
2477 | tests->add(BOOST_TEST_CASE(&move_container_values_noexcept)); | |
2478 | tests->add(BOOST_TEST_CASE(&check_containers_exception_specifications)); | |
2479 | #if !defined(BOOST_NO_CXX11_ALLOCATOR) | |
2480 | tests->add(BOOST_TEST_CASE(&cxx11_allocator_test)); | |
2481 | #endif | |
2482 | } | |
2483 |