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(x: 11);
20	v.push_back(x: 12);
21	v.push_back(x: 13);
22	v.push_back(x: 14);
23	v.push_back(x: 15);
24	v.push_back(x: 16);
25	v.push_back(x: 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(x: 1);
101	v.push_back(x: 2);
102	v.push_back(x: 3);
103	v.push_back(x: 4);
104	v.push_back(x: 5);
105	v.push_back(x: 6);
106	v.push_back(x: 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(cb&: cb1);
123	generic_test(cb&: cb2);
124	generic_test(cb&: 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(item: 1);
141	cb1.push_back(item: 2);
142	cb1.push_back(item: 3);
143	cb1.push_back(item: 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(cb&: cb1);
151	generic_test(cb&: 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(cb&: cb1);
255
256
257	CB_CONTAINER<MyInteger, my_allocator<MyInteger> > cb_a(10, 0);
258	generic_test(cb&: 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(x: 11);
293	v.push_back(x: 12);
294	v.push_back(x: 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(item: 1);
301	cb3.push_back(item: 2);
302	cb3.insert(pos: cb3.begin(), item: 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(cb&: cb1);
318	generic_test(cb&: cb3);
319	generic_test(cb&: cb4);
320	}
321
322	void rbegin_and_rend_test() {
323
324	vector<int> v;
325	v.push_back(x: 11);
326	v.push_back(x: 12);
327	v.push_back(x: 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(item: 1);
334	cb3.push_back(item: 2);
335	cb3.insert(pos: cb3.begin(), item: 3);
336	cb3.push_back(item: 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(cb&: cb1);
352	generic_test(cb&: cb3);
353	generic_test(cb&: cb4);
354	}
355
356	void element_access_and_insert_test() {
357
358	CB_CONTAINER<MyInteger> cb(3);
359	cb.push_back(item: 1);
360	cb.push_back(item: 2);
361	cb.insert(pos: cb.begin(), item: 3);
362	cb.push_back(item: 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(item: 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(item: 2);
398	cb.push_back(item: 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(x: 1);
410	v.push_back(x: 2);
411	v.push_back(x: 3);
412	v.push_back(x: 4);
413	v.push_back(x: 5);
414	v.push_back(x: 6);
415	v.push_back(x: 7);
416	v.push_back(x: 8);
417	v.push_back(x: 9);
418	v.push_back(x: 10);
419	v.push_back(x: 11);
420	v.push_back(x: 12);
421	CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.begin() + 10);
422	cb1.push_back(item: 11);
423	cb1.push_back(item: 12);
424	cb1.push_back(item: 13);
425	CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.begin() + 10);
426	cb2.push_back(item: 11);
427	cb2.push_back(item: 12);
428	cb2.push_back(item: 13);
429	cb2.push_back(item: 14);
430	cb2.push_back(item: 15);
431	cb2.push_back(item: 16);
432	cb2.push_back(item: 17);
433	CB_CONTAINER<MyInteger> cb3(10, v.begin(), v.begin() + 10);
434	cb3.push_back(item: 11);
435	cb3.push_back(item: 12);
436	cb3.push_back(item: 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(item: 13);
442	cb5.push_back(item: 14);
443	cb5.push_back(item: 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(item: -2);
452	cb6.push_back(item: -1);
453	cb6.push_back(item: 0);
454	cb6.push_back(item: 1);
455	cb6.push_back(item: 2);
456	cb6.push_back(item: 3);
457	cb6.push_back(item: 4);
458	cb6.push_back(item: 5);
459	cb6.push_back(item: 6);
460	cb6.pop_back();
461	CB_CONTAINER<MyInteger> cb7(6);
462	cb7.push_back(item: 0);
463	cb7.push_back(item: 1);
464	cb7.push_back(item: 2);
465	cb7.push_back(item: 3);
466	cb7.push_back(item: 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(cb&: cb1);
555	generic_test(cb&: cb2);
556	generic_test(cb&: cb3);
557	generic_test(cb&: cb4);
558	generic_test(cb&: cb5);
559	generic_test(cb&: cb6);
560	generic_test(cb&: 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(item: 1);
577	cb.push_back(item: 2);
578	cb.push_back(item: 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(item: 4);
594	cb.push_back(item: 5);
595	cb.push_back(item: 6);
596	cb.push_back(item: 7);
597	cb.push_back(item: 8);
598	cb.push_back(item: 9);
599	cb.push_back(item: 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(cb&: 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(item: 1);
691	cb2.push_back(item: 2);
692	cb2.push_back(item: 2);
693	cb2.push_back(item: 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(cb&: cb1);
707	generic_test(cb&: 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(item: 1);
717	cb2.push_back(item: 3);
718	cb2.push_back(item: 1);
719	cb2.push_back(item: 1);
720	cb2.push_back(item: 1);
721	cb3.push_back(item: 3);
722	cb3.push_back(item: 1);
723	cb4.push_back(item: 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(cb&: cb1);
732	generic_test(cb&: cb2);
733	generic_test(cb&: cb3);
734	generic_test(cb&: cb4);
735	}
736
737	void set_capacity_test() {
738
739	CB_CONTAINER<MyInteger> cb1(10);
740	cb1.push_back(item: 2);
741	cb1.push_back(item: 3);
742	cb1.push_back(item: 1);
743	cb1.set_capacity(5);
744	CB_CONTAINER<MyInteger> cb2(3);
745	cb2.push_back(item: 2);
746	cb2.push_back(item: 3);
747	cb2.push_back(item: 1);
748	cb2.set_capacity(10);
749	CB_CONTAINER<MyInteger> cb3(5);
750	cb3.push_back(item: 2);
751	cb3.push_back(item: 3);
752	cb3.push_back(item: 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(cb&: cb1);
781	generic_test(cb&: cb2);
782	generic_test(cb&: cb3);
783	}
784
785	void rset_capacity_test() {
786
787	CB_CONTAINER<MyInteger> cb1(10);
788	cb1.push_back(item: 2);
789	cb1.push_back(item: 3);
790	cb1.push_back(item: 1);
791	cb1.rset_capacity(new_capacity: 5);
792	CB_CONTAINER<MyInteger> cb2(3);
793	cb2.push_back(item: 2);
794	cb2.push_back(item: 3);
795	cb2.push_back(item: 1);
796	cb2.rset_capacity(new_capacity: 10);
797	CB_CONTAINER<MyInteger> cb3(5);
798	cb3.push_back(item: 2);
799	cb3.push_back(item: 3);
800	cb3.push_back(item: 1);
801	cb3.rset_capacity(new_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(new_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(new_capacity: 0);
824
825	BOOST_CHECK(cb3.size() == 0);
826	BOOST_CHECK(cb3.capacity() == 0);
827
828	generic_test(cb&: cb1);
829	generic_test(cb&: cb2);
830	generic_test(cb&: cb3);
831	}
832
833	void resize_test() {
834
835	CB_CONTAINER<MyInteger> cb1(10);
836	cb1.push_back(item: 1);
837	cb1.push_back(item: 2);
838	cb1.push_back(item: 3);
839	cb1.push_back(item: 4);
840	cb1.resize(new_size: 20, item: 5);
841	CB_CONTAINER<MyInteger> cb2(10);
842	cb2.push_back(item: 1);
843	cb2.push_back(item: 2);
844	cb2.push_back(item: 3);
845	cb2.push_back(item: 4);
846	cb2.resize(new_size: 2);
847	CB_CONTAINER<MyInteger> cb3(10, 1);
848	cb3.resize(new_size: 0);
849	CB_CONTAINER<MyInteger> cb4(10, 1);
850	cb4.resize(new_size: 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(cb&: cb1);
870	generic_test(cb&: cb2);
871	generic_test(cb&: cb3);
872	generic_test(cb&: cb4);
873	}
874
875	void rresize_test() {
876
877	CB_CONTAINER<MyInteger> cb1(10);
878	cb1.push_back(item: 1);
879	cb1.push_back(item: 2);
880	cb1.push_back(item: 3);
881	cb1.push_back(item: 4);
882	cb1.rresize(new_size: 20, item: 5);
883	CB_CONTAINER<MyInteger> cb2(10);
884	cb2.push_back(item: 1);
885	cb2.push_back(item: 2);
886	cb2.push_back(item: 3);
887	cb2.push_back(item: 4);
888	cb2.rresize(new_size: 2);
889	CB_CONTAINER<MyInteger> cb3(10, 1);
890	cb3.rresize(new_size: 0);
891	CB_CONTAINER<MyInteger> cb4(10, 1);
892	cb4.rresize(new_size: 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(cb&: cb1);
912	generic_test(cb&: cb2);
913	generic_test(cb&: cb3);
914	generic_test(cb&: 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(item: 1);
924	cb0.push_back(item: 2);
925	cb0.push_back(item: 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(x: 1);
934	v.push_back(x: 2);
935	v.push_back(x: 3);
936	v.push_back(x: 4);
937	v.push_back(x: 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(item: 6);
972	cb6.push_back(item: 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(cb&: cb1);
992	generic_test(cb&: cb2);
993	generic_test(cb&: cb3);
994	generic_test(cb&: cb4);
995	generic_test(cb&: cb5);
996	generic_test(cb&: cb6);
997	}
998
999	void assign_test() {
1000
1001	CB_CONTAINER<MyInteger> cb1(4);
1002	cb1.push_back(item: 1);
1003	cb1.push_back(item: 2);
1004	cb1.push_back(item: 3);
1005	cb1.push_back(item: 4);
1006	cb1.push_back(item: 5);
1007	cb1.assign(first: 3, last: 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(first: 6, last: 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(n: 3, item: 1.1f);
1021	BOOST_CHECK(cb2[0] == 1.1f);
1022
1023	CB_CONTAINER<MyInteger> cb3(5);
1024	cb3.push_back(item: 1);
1025	cb3.push_back(item: 2);
1026	cb3.push_back(item: 3);
1027	cb3.assign(n: (size_t)10, item: 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(x: 1);
1037	v.push_back(x: 2);
1038	v.push_back(x: 3);
1039	v.push_back(x: 4);
1040	v.push_back(x: 5);
1041
1042	CB_CONTAINER<int> cb4(3);
1043	cb4.assign(first: MyInputIterator(v.begin()), last: MyInputIterator(v.end()));
1044	CB_CONTAINER<int> cb5(3);
1045	cb5.assign(buffer_capacity: 4, first: MyInputIterator(v.begin()), last: 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(cb&: cb1);
1053	generic_test(cb&: cb3);
1054	}
1055
1056	void copy_constructor_and_assign_test() {
1057
1058	CB_CONTAINER<MyInteger> cb1(4);
1059	cb1.push_back(item: 1);
1060	cb1.push_back(item: 2);
1061	cb1.push_back(item: 3);
1062	cb1.push_back(item: 4);
1063	cb1.push_back(item: 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(cb&: cb1);
1094	generic_test(cb&: cb2);
1095	generic_test(cb&: cb3);
1096	generic_test(cb&: cb4);
1097	generic_test(cb&: cb5);
1098	}
1099
1100	void swap_test() {
1101
1102	CB_CONTAINER<MyInteger> cb1(2);
1103	cb1.push_back(item: 1);
1104	cb1.push_back(item: 2);
1105	cb1.push_back(item: 3);
1106	CB_CONTAINER<MyInteger> cb2(5);
1107	cb2.push_back(item: 8);
1108	cb2.swap(cb&: cb1);
1109	cb2.swap(cb&: 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(cb&: cb1);
1119	generic_test(cb&: cb2);
1120	}
1121
1122	void push_back_test() {
1123
1124	CB_CONTAINER<MyDefaultConstructible> cb1(5);
1125	cb1.push_back();
1126	cb1.push_back(item: 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(item: 1);
1135	BOOST_CHECK(cb2.back() == 1);
1136
1137	generic_test(cb&: cb2);
1138	}
1139
1140	void pop_back_test() {
1141
1142	CB_CONTAINER<MyInteger> cb(4);
1143	cb.push_back(item: 1);
1144	cb.push_back(item: 2);
1145	cb.push_back(item: 3);
1146	cb.push_back(item: 4);
1147	cb.push_back(item: 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(item: 1);
1161	cb1.push_back(item: 2);
1162	cb1.push_back(item: 3);
1163	CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1;
1164	it1 = cb1.insert(pos: it1, item: 10);
1165	CB_CONTAINER<MyInteger> cb2(4);
1166	cb2.push_back(item: 1);
1167	cb2.insert(pos: cb2.begin());
1168	cb2.insert(pos: cb2.begin(), item: -1);
1169	CB_CONTAINER<MyInteger>::iterator it2 = cb2.begin() + 1;
1170	it2 = cb2.insert(pos: it2, item: 5);
1171	CB_CONTAINER<MyInteger> cb3(2);
1172	cb3.insert(pos: cb3.end(), item: 10);
1173	cb3.insert(pos: cb3.end(), item: 20);
1174	cb3.insert(pos: cb3.begin(), item: 30);
1175	cb3.insert(pos: cb3.end(), item: 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(cb&: cb1);
1187	generic_test(cb&: cb2);
1188	generic_test(cb&: cb3);
1189	}
1190
1191	void insert_n_test() {
1192
1193	CB_CONTAINER<MyInteger> cb1(4);
1194	cb1.push_back(item: 1);
1195	cb1.push_back(item: 2);
1196	cb1.push_back(item: 3);
1197	cb1.insert(pos: cb1.begin() + 1, first: 2, last: 10);
1198	CB_CONTAINER<MyInteger> cb2(2, 3);
1199	cb2.insert(pos: cb2.begin(), first: 10, last: 5);
1200	CB_CONTAINER<MyInteger> cb3(4);
1201	cb3.insert(pos: cb3.end(), first: 1, last: 6);
1202	CB_CONTAINER<MyInteger> cb4(6);
1203	cb4.push_back(item: 1);
1204	cb4.push_back(item: 2);
1205	cb4.push_back(item: 3);
1206	cb4.push_back(item: 4);
1207	cb4.insert(pos: cb4.begin() + 2, first: 5, last: 6);
1208	cb4.insert(pos: cb4.begin() + 2, first: 0, last: 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(cb&: cb1);
1228	generic_test(cb&: cb2);
1229	generic_test(cb&: cb3);
1230	generic_test(cb&: cb4);
1231	}
1232
1233	void insert_range_test() {
1234
1235	vector<int> v;
1236	v.push_back(x: 11);
1237	v.push_back(x: 12);
1238	v.push_back(x: 13);
1239	CB_CONTAINER<MyInteger> cb1(4);
1240	cb1.push_back(item: 1);
1241	cb1.push_back(item: 2);
1242	cb1.push_back(item: 3);
1243	cb1.insert(pos: cb1.begin() + 1, first: v.begin(), last: v.end());
1244	CB_CONTAINER<MyInteger> cb2(2, 2);
1245	cb2.insert(pos: cb2.end(), first: v.begin(), last: v.end());
1246	CB_CONTAINER<MyInteger> cb3(5);
1247	cb3.insert(pos: cb3.end(), first: v.end(), last: v.end());
1248	CB_CONTAINER<MyInteger> cb4(5);
1249	cb4.insert(pos: cb4.end(), first: v.begin(), last: v.begin() + 1);
1250	MyInteger array[] = { 5, 6, 7, 8, 9 };
1251	CB_CONTAINER<MyInteger> cb5(6);
1252	cb5.push_back(item: 1);
1253	cb5.push_back(item: 2);
1254	cb5.push_back(item: 3);
1255	cb5.push_back(item: 4);
1256	cb5.insert(pos: cb5.begin() + 2, first: array, last: array + 5);
1257	cb5.insert(pos: cb5.begin(), first: array, last: 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(x: 1);
1281	v.push_back(x: 2);
1282	v.push_back(x: 3);
1283	v.push_back(x: 4);
1284	v.push_back(x: 5);
1285
1286	CB_CONTAINER<int> cb6(4);
1287	cb6.push_back(item: 0);
1288	cb6.push_back(item: -1);
1289	cb6.push_back(item: -2);
1290	cb6.insert(pos: cb6.begin() + 1, first: MyInputIterator(v.begin()), last: MyInputIterator(v.end()));
1291	v.clear();
1292	v.push_back(x: 11);
1293	v.push_back(x: 12);
1294	v.push_back(x: 13);
1295	CB_CONTAINER<int> cb7(4);
1296	cb7.push_back(item: 1);
1297	cb7.push_back(item: 2);
1298	cb7.push_back(item: 3);
1299	cb7.insert(pos: cb7.begin() + 1, first: MyInputIterator(v.begin()), last: MyInputIterator(v.end()));
1300	CB_CONTAINER<int> cb8(2, 2);
1301	cb8.insert(pos: cb8.end(), first: MyInputIterator(v.begin()), last: MyInputIterator(v.end()));
1302	CB_CONTAINER<int> cb9(5);
1303	cb9.insert(pos: cb9.end(), first: MyInputIterator(v.end()), last: MyInputIterator(v.end()));
1304	CB_CONTAINER<int> cb10(5);
1305	cb10.insert(pos: cb10.end(), first: MyInputIterator(v.begin()), last: MyInputIterator(v.begin() + 1));
1306	v.clear();
1307	v.push_back(x: 5);
1308	v.push_back(x: 6);
1309	v.push_back(x: 7);
1310	v.push_back(x: 8);
1311	v.push_back(x: 9);
1312	CB_CONTAINER<int> cb11(6);
1313	cb11.push_back(item: 1);
1314	cb11.push_back(item: 2);
1315	cb11.push_back(item: 3);
1316	cb11.push_back(item: 4);
1317	cb11.insert(pos: cb11.begin() + 2, first: MyInputIterator(v.begin()), last: MyInputIterator(v.begin() + 5));
1318	cb11.insert(pos: cb11.begin(), first: MyInputIterator(v.begin()), last: 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(cb&: cb1);
1344	generic_test(cb&: cb2);
1345	generic_test(cb&: cb3);
1346	generic_test(cb&: cb4);
1347	generic_test(cb&: cb5);
1348	}
1349
1350	void push_front_test() {
1351
1352	CB_CONTAINER<MyDefaultConstructible> cb1(5);
1353	cb1.push_front();
1354	cb1.push_front(item: 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(item: 1);
1363	BOOST_CHECK(cb2.front() == 1);
1364
1365	CB_CONTAINER<MyInteger> cb3(0);
1366	cb3.push_front(item: 10);
1367	BOOST_CHECK(cb3.empty());
1368
1369	generic_test(cb&: cb2);
1370	generic_test(cb&: cb3);
1371	}
1372
1373	void pop_front_test() {
1374
1375	CB_CONTAINER<MyInteger> cb(4);
1376	cb.push_front(item: 1);
1377	cb.push_front(item: 2);
1378	cb.push_front(item: 3);
1379	cb.push_front(item: 4);
1380	cb.push_front(item: 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(item: 1);
1394	cb1.push_front(item: 2);
1395	cb1.push_front(item: 3);
1396	CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1;
1397	it1 = cb1.rinsert(pos: it1, item: 10);
1398	CB_CONTAINER<MyInteger> cb2(4);
1399	cb2.push_front(item: 1);
1400	cb2.rinsert(pos: cb2.begin());
1401	cb2.rinsert(pos: cb2.begin(), item: -1);
1402	CB_CONTAINER<MyInteger>::iterator it2 = cb2.end() - 2;
1403	it2 = cb2.rinsert(pos: it2, item: 5);
1404	CB_CONTAINER<MyInteger> cb3(2);
1405	cb3.rinsert(pos: cb3.begin(), item: 10);
1406	cb3.rinsert(pos: cb3.begin(), item: 20);
1407	cb3.rinsert(pos: cb3.end(), item: 30);
1408	cb3.rinsert(pos: cb3.begin(), item: 40);
1409	CB_CONTAINER<MyInteger> cb4(4);
1410	cb4.push_back(item: 1);
1411	cb4.push_back(item: 2);
1412	cb4.push_back(item: 3);
1413	CB_CONTAINER<MyInteger>::iterator it3 = cb4.begin() + 1;
1414	it3 = cb4.rinsert(pos: it3, item: 10);
1415	CB_CONTAINER<MyInteger> cb5(4);
1416	cb5.push_back(item: 1);
1417	cb5.rinsert(pos: cb5.begin(), item: 0);
1418	cb5.rinsert(pos: cb5.begin(), item: -1);
1419	CB_CONTAINER<MyInteger>::iterator it4 = cb5.begin() + 1;
1420	it4 = cb5.rinsert(pos: it4, item: 5);
1421	CB_CONTAINER<MyInteger> cb6(2);
1422	cb6.rinsert(pos: cb6.end(), item: 10);
1423	cb6.rinsert(pos: cb6.end(), item: 20);
1424	cb6.rinsert(pos: cb6.begin(), item: 30);
1425	cb6.rinsert(pos: cb6.end(), item: 40);
1426	CB_CONTAINER<MyInteger> cb7(6);
1427	cb7.push_back(item: 1);
1428	cb7.push_back(item: 2);
1429	cb7.push_back(item: 3);
1430	cb7.push_back(item: 4);
1431	cb7.rinsert(pos: cb7.begin() + 2, first: 5, last: 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(cb&: cb1);
1459	generic_test(cb&: cb2);
1460	generic_test(cb&: cb3);
1461	generic_test(cb&: cb4);
1462	generic_test(cb&: cb5);
1463	generic_test(cb&: cb6);
1464	generic_test(cb&: cb7);
1465	}
1466
1467	void rinsert_n_test() {
1468
1469	CB_CONTAINER<MyInteger> cb1(4);
1470	cb1.push_front(item: 1);
1471	cb1.push_front(item: 2);
1472	cb1.push_front(item: 3);
1473	cb1.rinsert(pos: cb1.begin() + 1, first: 2, last: 10);
1474	CB_CONTAINER<MyInteger> cb2(2, 3);
1475	cb2.rinsert(pos: cb2.begin(), first: 10, last: 5);
1476	CB_CONTAINER<MyInteger> cb3(4);
1477	cb3.rinsert(pos: cb3.end(), first: 1, last: 6);
1478	CB_CONTAINER<MyInteger> cb4(4);
1479	cb4.push_back(item: 1);
1480	cb4.push_back(item: 2);
1481	cb4.push_back(item: 3);
1482	cb4.rinsert(pos: cb4.begin() + 1, first: 2, last: 10);
1483	MyInteger array[] = { 5, 6, 7, 8, 9 };
1484	CB_CONTAINER<MyInteger> cb5(6);
1485	cb5.push_back(item: 1);
1486	cb5.push_back(item: 2);
1487	cb5.push_back(item: 3);
1488	cb5.push_back(item: 4);
1489	cb5.rinsert(pos: cb5.begin() + 2, first: array, last: array + 5);
1490	cb5.rinsert(pos: cb5.end(), first: array, last: 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(cb&: cb1);
1515	generic_test(cb&: cb2);
1516	generic_test(cb&: cb3);
1517	generic_test(cb&: cb4);
1518	generic_test(cb&: cb5);
1519	}
1520
1521	void rinsert_range_test() {
1522
1523	vector<int> v;
1524	v.push_back(x: 11);
1525	v.push_back(x: 12);
1526	v.push_back(x: 13);
1527	v.push_back(x: 14);
1528	CB_CONTAINER<MyInteger> cb1(4);
1529	cb1.push_back(item: 1);
1530	cb1.push_back(item: 2);
1531	cb1.push_back(item: 3);
1532	cb1.rinsert(pos: cb1.begin() + 1, first: v.begin(), last: v.end());
1533	CB_CONTAINER<MyInteger> cb2(2, 2);
1534	cb2.rinsert(pos: cb2.begin(), first: v.begin(), last: v.end());
1535	CB_CONTAINER<MyInteger> cb3(5);
1536	cb3.rinsert(pos: cb3.begin(), first: v.end(), last: v.end());
1537	CB_CONTAINER<MyInteger> cb4(5);
1538	cb4.rinsert(pos: cb4.begin(), first: v.begin(), last: 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(x: 1);
1555	v.push_back(x: 2);
1556	v.push_back(x: 3);
1557	v.push_back(x: 4);
1558	v.push_back(x: 5);
1559
1560	CB_CONTAINER<int> cb10(4);
1561	cb10.push_back(item: 0);
1562	cb10.push_back(item: -1);
1563	cb10.push_back(item: -2);
1564	cb10.rinsert(pos: cb10.begin() + 1, first: MyInputIterator(v.begin()), last: MyInputIterator(v.end()));
1565	v.clear();
1566	v.push_back(x: 11);
1567	v.push_back(x: 12);
1568	v.push_back(x: 13);
1569	v.push_back(x: 14);
1570	CB_CONTAINER<int> cb11(4);
1571	cb11.push_back(item: 1);
1572	cb11.push_back(item: 2);
1573	cb11.push_back(item: 3);
1574	cb11.rinsert(pos: cb11.begin() + 1, first: MyInputIterator(v.begin()), last: MyInputIterator(v.end()));
1575	CB_CONTAINER<int> cb12(2, 2);
1576	cb12.rinsert(pos: cb12.begin(), first: MyInputIterator(v.begin()), last: MyInputIterator(v.end()));
1577	CB_CONTAINER<int> cb13(5);
1578	cb13.rinsert(pos: cb13.begin(), first: MyInputIterator(v.end()), last: MyInputIterator(v.end()));
1579	CB_CONTAINER<int> cb14(5);
1580	cb14.rinsert(pos: cb14.begin(), first: MyInputIterator(v.begin()), last: 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(cb&: cb1);
1599	generic_test(cb&: cb2);
1600	generic_test(cb&: cb3);
1601	generic_test(cb&: cb4);
1602	}
1603
1604	void erase_test() {
1605
1606	CB_CONTAINER<MyInteger> cb1(4);
1607	cb1.push_back(item: 1);
1608	cb1.push_back(item: 2);
1609	cb1.push_back(item: 3);
1610	CB_CONTAINER<MyInteger>::iterator it1 = cb1.erase(pos: cb1.begin() + 1);
1611
1612	CB_CONTAINER<MyInteger> cb2(1, 1);
1613	CB_CONTAINER<MyInteger>::iterator it2 = cb2.erase(pos: cb2.begin());
1614
1615	CB_CONTAINER<MyInteger> cb3(4);
1616	cb3.push_back(item: 1);
1617	cb3.push_back(item: 2);
1618	cb3.push_back(item: 3);
1619	CB_CONTAINER<MyInteger>::iterator it3 = cb3.erase(pos: 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(cb&: cb1);
1636	generic_test(cb&: cb2);
1637	generic_test(cb&: cb3);
1638	}
1639
1640	void erase_range_test() {
1641
1642	CB_CONTAINER<MyInteger> cb1(4);
1643	cb1.push_back(item: 1);
1644	cb1.push_back(item: 2);
1645	cb1.push_back(item: 3);
1646	cb1.push_back(item: 4);
1647	CB_CONTAINER<MyInteger>::iterator it1 = cb1.erase(first: cb1.begin() + 1, last: cb1.begin() + 3);
1648
1649	CB_CONTAINER<MyInteger> cb2(4);
1650	cb2.push_back(item: 1);
1651	cb2.push_back(item: 2);
1652	cb2.push_back(item: 3);
1653	cb2.push_back(item: 4);
1654	CB_CONTAINER<MyInteger>::iterator it2 = cb2.erase(first: cb2.begin(), last: cb2.begin());
1655
1656	CB_CONTAINER<MyInteger> cb3(4);
1657	cb3.push_back(item: 1);
1658	cb3.push_back(item: 2);
1659	cb3.push_back(item: 3);
1660	cb3.push_back(item: 4);
1661	CB_CONTAINER<MyInteger>::iterator it3 = cb3.erase(first: cb3.begin() + 2, last: cb3.end());
1662
1663	CB_CONTAINER<MyInteger> cb4(10, 1);
1664	CB_CONTAINER<MyInteger>::iterator it4 = cb4.erase(first: cb4.begin(), last: 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(cb&: cb1);
1685	generic_test(cb&: cb2);
1686	generic_test(cb&: cb3);
1687	generic_test(cb&: cb4);
1688	}
1689
1690	void rerase_test() {
1691
1692	CB_CONTAINER<MyInteger> cb1(4);
1693	cb1.push_back(item: 1);
1694	cb1.push_back(item: 2);
1695	cb1.push_back(item: 3);
1696	CB_CONTAINER<MyInteger>::iterator it1 = cb1.rerase(pos: cb1.begin() + 1);
1697
1698	CB_CONTAINER<MyInteger> cb2(1, 1);
1699	CB_CONTAINER<MyInteger>::iterator it2 = cb2.rerase(pos: cb2.begin());
1700
1701	CB_CONTAINER<MyInteger> cb3(4);
1702	cb3.push_back(item: 1);
1703	cb3.push_back(item: 2);
1704	cb3.push_back(item: 3);
1705	CB_CONTAINER<MyInteger>::iterator it3 = cb3.rerase(pos: 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(cb&: cb1);
1723	generic_test(cb&: cb2);
1724	generic_test(cb&: cb3);
1725	}
1726
1727	void rerase_range_test() {
1728
1729	CB_CONTAINER<MyInteger> cb1(4);
1730	cb1.push_back(item: 1);
1731	cb1.push_back(item: 2);
1732	cb1.push_back(item: 3);
1733	cb1.push_back(item: 4);
1734	CB_CONTAINER<MyInteger>::iterator it1 = cb1.rerase(first: cb1.begin() + 1, last: cb1.begin() + 3);
1735
1736	CB_CONTAINER<MyInteger> cb2(4);
1737	cb2.push_back(item: 1);
1738	cb2.push_back(item: 2);
1739	cb2.push_back(item: 3);
1740	cb2.push_back(item: 4);
1741	CB_CONTAINER<MyInteger>::iterator it2 = cb2.rerase(first: cb2.begin(), last: cb2.begin());
1742
1743	CB_CONTAINER<MyInteger> cb3(4);
1744	cb3.push_back(item: 1);
1745	cb3.push_back(item: 2);
1746	cb3.push_back(item: 3);
1747	cb3.push_back(item: 4);
1748	CB_CONTAINER<MyInteger>::iterator it3 = cb3.rerase(first: cb3.begin(), last: cb3.begin() + 2);
1749
1750	CB_CONTAINER<MyInteger> cb4(10, 1);
1751	CB_CONTAINER<MyInteger>::iterator it4 = cb4.rerase(first: cb4.begin(), last: 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(cb&: cb1);
1772	generic_test(cb&: cb2);
1773	generic_test(cb&: cb3);
1774	generic_test(cb&: cb4);
1775	}
1776
1777	void clear_test() {
1778
1779	CB_CONTAINER<MyInteger> cb(4);
1780	cb.push_back(item: 1);
1781	cb.push_back(item: 2);
1782	cb.push_back(item: 3);
1783	cb.push_back(item: 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(item: 1);
1795	cb1.push_back(item: 2);
1796	cb1.push_back(item: 3);
1797	cb1.push_back(item: 4);
1798	CB_CONTAINER<MyInteger> cb2(10);
1799	cb2.push_back(item: 1);
1800	cb2.push_back(item: 2);
1801	cb2.push_back(item: 3);
1802	cb2.push_back(item: 4);
1803
1804	BOOST_CHECK(cb1 == cb2);
1805	BOOST_CHECK(!(cb2 != cb1));
1806
1807	generic_test(cb&: cb1);
1808	generic_test(cb&: cb2);
1809	}
1810
1811	void lexicographical_comparison_test() {
1812
1813	CB_CONTAINER<char> cb1(10);
1814	cb1.push_back(item: 'a');
1815	cb1.push_back(item: 'd');
1816	cb1.push_back(item: 'a');
1817	cb1.push_back(item: 'm');
1818	CB_CONTAINER<char> cb2(5);
1819	cb2.push_back(item: 'j');
1820	cb2.push_back(item: 'o');
1821	cb2.push_back(item: 'h');
1822	cb2.push_back(item: '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(x: 11);
1832	v.push_back(x: 12);
1833	v.push_back(x: 13);
1834	CB_CONTAINER<MyInteger> cb1(4);
1835	cb1.push_back(item: 1);
1836	cb1.push_back(item: 2);
1837	cb1.push_back(item: 3);
1838	cb1.assign(first: v.begin() + 1, last: v.end());
1839	CB_CONTAINER<MyInteger> cb2(2);
1840	cb2.push_back(item: 1);
1841	cb2.push_back(item: 2);
1842	cb2.assign(first: v.begin(), last: 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(cb&: cb1);
1855	generic_test(cb&: 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(item: 1);
1863	cb1.push_back(item: 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(item: 3);
1872	cb1.push_back(item: 4);
1873	int sum = accumulate(first: cb1.begin(), last: cb1.end(), init: 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(pos: cb2.begin(), item: 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(x: 100);
1897	v.push_back(x: 200);
1898	v.push_back(x: 300);
1899	cb2.insert(pos: cb2.begin() + 1, first: v.begin(), last: 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(item: 1);
1909	cb3.push_back(item: 2);
1910	cb3.push_back(item: 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(item: 4);
1917	cb3.push_back(item: 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(item: InstanceCounter());
1933	cb.push_back(item: InstanceCounter());
1934	cb.push_back(item: 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(x: 1);
1947	v.push_back(x: 2);
1948	v.push_back(x: 3);
1949	v.push_back(x: 4);
1950	v.push_back(x: 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(item: 1);
1967	cb1.push_back(item: 2);
1968	cb1.push_back(item: 3);
1969	cb1.push_back(item: 4);
1970	cb1.push_back(item: 5);
1971	cb1.push_back(item: 6);
1972	cb1.push_back(item: 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(new_begin: it1);
1983	rotate(first: cb2.begin(), middle: cb2.begin() + 2, last: cb2.end());
1984
1985	CB_CONTAINER<MyInteger> cb3(7);
1986	cb3.push_back(item: 1);
1987	cb3.push_back(item: 2);
1988	cb3.push_back(item: 3);
1989	cb3.push_back(item: 4);
1990	cb3.push_back(item: 5);
1991	cb3.push_back(item: 6);
1992	cb3.push_back(item: 7);
1993	cb3.push_back(item: 8);
1994	cb3.push_back(item: 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(new_begin: it2);
2005	rotate(first: cb4.begin(), middle: cb4.begin() + 1, last: cb4.end());
2006
2007	CB_CONTAINER<MyInteger> cb5(10);
2008	cb5.push_back(item: 1);
2009	cb5.push_back(item: 2);
2010	cb5.push_back(item: 3);
2011	cb5.push_back(item: 4);
2012	cb5.push_back(item: 5);
2013	cb5.push_back(item: 6);
2014	cb5.push_back(item: 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(new_begin: it3);
2025	rotate(first: cb6.begin(), middle: cb6.begin() + 5, last: 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(cb&: cb1);
2072	generic_test(cb&: cb2);
2073	generic_test(cb&: cb3);
2074	generic_test(cb&: cb4);
2075	generic_test(cb&: cb5);
2076	generic_test(cb&: 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(item: 1);
2086	cb1.push_back(item: 2);
2087	cb1.push_back(item: 3);
2088	cb1.push_back(item: 4);
2089	cb1.push_back(item: 5);
2090	cb1.push_back(item: 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(new_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(new_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(&copy_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
2484