1//
2// Boost.Pointer Container
3//
4// Copyright Thorsten Ottosen 2003-2005. Use, modification and
5// distribution is subject to the Boost Software License, Version
6// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
7// http://www.boost.org/LICENSE_1_0.txt)
8//
9// For more information, see http://www.boost.org/libs/ptr_container/
10//
11
12#include <boost/test/unit_test.hpp>
13#include "sequence_test_data.hpp"
14#include <boost/ptr_container/ptr_circular_buffer.hpp>
15#include <boost/ptr_container/ptr_list.hpp>
16#include <boost/assign/list_inserter.hpp>
17
18template<class T>
19struct set_capacity< ptr_circular_buffer<T> >
20{
21 void operator()( ptr_circular_buffer<T>& c ) const
22 {
23 c.set_capacity( 100u );
24 }
25};
26
27void test_ptr_circular_buffer()
28{
29 reversible_container_test< ptr_circular_buffer<Base>, Base, Derived_class >();
30 reversible_container_test< ptr_circular_buffer<Value>, Value, Value >();
31
32#ifdef BOOST_NO_SFINAE
33#else
34 reversible_container_test< ptr_circular_buffer< nullable<Base> >, Base, Derived_class >();
35 reversible_container_test< ptr_circular_buffer< nullable<Value> >, Value, Value >();
36#endif
37
38 container_assignment_test< ptr_circular_buffer<Base>, ptr_circular_buffer<Derived_class>,
39 Derived_class>();
40 container_assignment_test< ptr_circular_buffer< nullable<Base> >,
41 ptr_circular_buffer< nullable<Derived_class> >,
42 Derived_class>();
43 container_assignment_test< ptr_circular_buffer< nullable<Base> >,
44 ptr_circular_buffer<Derived_class>,
45 Derived_class>();
46 container_assignment_test< ptr_circular_buffer<Base>,
47 ptr_circular_buffer< nullable<Derived_class> >,
48 Derived_class>();
49
50 test_transfer< ptr_circular_buffer<Derived_class>, ptr_circular_buffer<Base>, Derived_class>();
51 test_transfer< ptr_circular_buffer<Derived_class>, ptr_list<Base>, Derived_class>();
52
53 random_access_algorithms_test< ptr_circular_buffer<int> >();
54
55
56 BOOST_TEST_MESSAGE( "starting ptr_circular_buffer test" );
57 ptr_circular_buffer<int> vec( 100u );
58 BOOST_CHECK( vec.capacity() >= 100u );
59
60#ifdef BOOST_PTR_CONTAINER_NO_EXCEPTIONS
61#else
62
63 BOOST_CHECK_THROW( vec.push_back(0), bad_ptr_container_operation );
64 BOOST_CHECK_THROW( (vec.insert( vec.begin(), 0 )), bad_ptr_container_operation );
65 BOOST_CHECK_THROW( vec.at( 42 ), bad_ptr_container_operation );
66 vec.push_back( ptr: new int(0) );
67 BOOST_CHECK_THROW( (vec.replace(10u, new int(0))), bad_ptr_container_operation );
68 BOOST_CHECK_THROW( (vec.replace(0u, 0)), bad_ptr_container_operation );
69 BOOST_CHECK_THROW( (vec.replace(vec.begin(), 0 )), bad_ptr_container_operation );
70
71#endif
72
73 vec.clear();
74 assign::push_back( c&: vec )( new int(2) )
75 ( new int(4) )
76 ( new int(6) )
77 ( new int(8) );
78 ptr_circular_buffer<int> vec2( 100u );
79 assign::push_back( c&: vec2 )
80 ( new int(1) )
81 ( new int(3) )
82 ( new int(5) )
83 ( new int(7) );
84 BOOST_CHECK_EQUAL( vec.size(), vec2.size() );
85 BOOST_CHECK( vec > vec2 );
86 BOOST_CHECK( vec != vec2 );
87 BOOST_CHECK( !(vec == vec2) );
88 BOOST_CHECK( vec2 < vec );
89 BOOST_CHECK( vec2 <= vec );
90 BOOST_CHECK( vec >= vec2 );
91
92 BOOST_TEST_MESSAGE( "push_front test" );
93 assign::push_front( c&: vec2 )
94 ( new int(2) )
95 ( new int(4) )
96 ( new int(6) )
97 ( new int(8) );
98 BOOST_CHECK_EQUAL( vec2.size(), 8u );
99 BOOST_CHECK_EQUAL( vec2[0], 8 );
100 BOOST_CHECK_EQUAL( vec2.front(), 8 );
101 BOOST_CHECK_EQUAL( vec2.back(), 7 );
102
103 //vec2.linearize();
104 vec2.rset_capacity( new_capacity: vec2.size() - 2u );
105 vec2.rresize( size: 0 );
106 //vec2.reverse();
107
108 BOOST_TEST_MESSAGE( "when full test" );
109
110 ptr_circular_buffer<int> vec3;
111 BOOST_CHECK_EQUAL( vec3.capacity(), 0u );
112 vec3.set_capacity( 2u );
113 BOOST_CHECK_EQUAL( vec3.capacity(), 2u );
114
115 vec3.push_back( ptr: new int(1) );
116 vec3.push_back( ptr: new int(2) );
117 BOOST_CHECK_EQUAL( vec3.size(), 2u );
118 BOOST_CHECK( vec3.full() );
119
120 vec3.push_back( ptr: new int(3) );
121 BOOST_CHECK_EQUAL( vec3.front(), 2 );
122 BOOST_CHECK_EQUAL( vec3.back(), 3 );
123
124 vec3.push_front( ptr: new int(4) );
125 BOOST_CHECK_EQUAL( vec3.size(), 2u );
126 BOOST_CHECK_EQUAL( vec3.front(), 4 );
127 BOOST_CHECK_EQUAL( vec3.back(), 2 );
128
129 vec3.insert( pos: vec3.end(), ptr: new int(5) );
130 BOOST_CHECK_EQUAL( vec3.front(), 2 );
131 BOOST_CHECK_EQUAL( vec3.back(), 5 );
132
133 vec3.rinsert( pos: vec3.begin(), ptr: new int(6) );
134 BOOST_CHECK_EQUAL( vec3.front(), 6 );
135 BOOST_CHECK_EQUAL( vec3.back(), 2 );
136
137 BOOST_TEST_MESSAGE( "transfer test" );
138 ptr_circular_buffer<int> vec4(2u);
139 vec4.transfer( before: vec4.end(), from&: vec3 );
140 BOOST_CHECK_EQUAL( vec4.size(), 2u );
141 BOOST_CHECK_EQUAL( vec3.size(), 0u );
142 vec3.set_capacity(1u);
143 vec3.transfer( before: vec3.end(), from&: vec4 );
144 BOOST_CHECK_EQUAL( vec4.size(), 0u );
145 BOOST_CHECK_EQUAL( vec3.size(), 1u );
146 BOOST_CHECK_EQUAL( vec3.front(), 2 );
147
148 BOOST_TEST_MESSAGE( "rerase test" );
149 vec.rerase( pos: vec.begin() );
150 vec.rerase( r: boost::make_iterator_range( r&: vec ) );
151
152 BOOST_TEST_MESSAGE( "array test" );
153 const int data_size = 10;
154 int** array = new int*[data_size];
155 for( int i = 0; i != data_size; ++i )
156 array[i] = new int(i);
157
158 vec.transfer( before: vec.begin(), from: array, size: data_size );
159 int** array2 = vec.c_array();
160 BOOST_CHECK( array2 != array );
161
162 ptr_circular_buffer<int>::array_range array_range = vec.array_one();
163 array_range = vec.array_two();
164 ptr_circular_buffer<int>::const_array_range const_array_range = array_range;
165 const_array_range = const_cast< const ptr_circular_buffer<int>& >(vec).array_one();
166 const_array_range = const_cast< const ptr_circular_buffer<int>& >(vec).array_two();
167
168 BOOST_TEST_MESSAGE( "finishing ptr_circular_buffer test" );
169
170}
171
172
173
174void test_circular_buffer()
175{
176 boost::circular_buffer<void*> b(25u);
177 BOOST_CHECK_EQUAL( b.capacity(), 25u );
178 b.push_back( item: 0 );
179 BOOST_CHECK_EQUAL( b.size(), 1u );
180 boost::circular_buffer<void*> b2( b.begin(), b.end() );
181 BOOST_CHECK_EQUAL( b2.size(), b.size() );
182}
183
184using boost::unit_test::test_suite;
185
186test_suite* init_unit_test_suite( int argc, char* argv[] )
187{
188 test_suite* test = BOOST_TEST_SUITE( "Pointer Container Test Suite" );
189
190 test->add( BOOST_TEST_CASE( &test_circular_buffer ) );
191 test->add( BOOST_TEST_CASE( &test_ptr_circular_buffer ) );
192
193 return test;
194}
195
196
197
198
199

source code of boost/libs/ptr_container/test/ptr_circular_buffer.cpp