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 "test_data.hpp"
13 #include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
14 #include <boost/range/iterator_range.hpp>
15 #include <boost/bind.hpp>
16
17 #if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
18 #pragma GCC diagnostic push
19 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
20 #endif
21
22 template< typename C, typename B, typename T >
23 void reversible_container_test();
24
25 template< class IntContainer >
26 void algorithms_test();
27
28 template< typename C, typename B, typename T >
reversible_container_test()29 void reversible_container_test()
30 {
31 using namespace boost;
32
33 BOOST_TEST_MESSAGE( "starting reversible container test" );
34 enum { max_cnt = 10 };
35 C c;
36 set_capacity<C>()( c );
37 BOOST_CHECK( c.size() == 0 );
38 c.push_back( new T );
39 BOOST_CHECK( c.size() == 1 );
40
41 const C c2_dummy( c.begin(), c.end() );
42 BOOST_CHECK_EQUAL( c2_dummy.size(), c.size() );
43 const C c2( c.clone() );
44 BOOST_CHECK_EQUAL( c2.size(), c.size() );
45
46 C c3( c.begin(), c.end() );
47 set_capacity<C>()( c3 );
48 BOOST_CHECK_EQUAL( c.size(), c3.size() );
49
50 c.assign( c3.begin(), c3.end() );
51 BOOST_CHECK_EQUAL( c.size(), c3.size() );
52
53 c.assign( c3 );
54 set_capacity<C>()( c );
55 BOOST_TEST_MESSAGE( "finished construction test" );
56
57 C a_copy( c );
58 BOOST_CHECK_EQUAL( a_copy.size(), c.size() );
59 a_copy = a_copy;
60 BOOST_CHECK_EQUAL( a_copy.size(), c.size() );
61 a_copy.clear();
62 a_copy = a_copy;
63 BOOST_CHECK( a_copy.empty() );
64 BOOST_CHECK( !c.empty() );
65 BOOST_TEST_MESSAGE( "finished copying test" );
66
67 BOOST_DEDUCED_TYPENAME C::allocator_type alloc = c.get_allocator();
68 hide_warning(alloc);
69 BOOST_DEDUCED_TYPENAME C::iterator i = c.begin();
70 BOOST_DEDUCED_TYPENAME C::const_iterator ci = c2.begin();
71 BOOST_DEDUCED_TYPENAME C::iterator i2 = c.end();
72 hide_warning(i2);
73 BOOST_DEDUCED_TYPENAME C::const_iterator ci2 = c2.begin();
74 hide_warning(ci2);
75 BOOST_DEDUCED_TYPENAME C::reverse_iterator ri = c.rbegin();
76 hide_warning(ri);
77 BOOST_DEDUCED_TYPENAME C::const_reverse_iterator cri = c2.rbegin();
78 hide_warning(cri);
79 BOOST_DEDUCED_TYPENAME C::reverse_iterator rv2 = c.rend();
80 hide_warning(rv2);
81 BOOST_DEDUCED_TYPENAME C::const_reverse_iterator cvr2 = c2.rend();
82 hide_warning(cvr2);
83 i = c.rbegin().base();
84 ci = c2.rbegin().base();
85 i = c.rend().base();
86 ci = c2.rend().base();
87 BOOST_CHECK_EQUAL( std::distance( c.rbegin(), c.rend() ),
88 std::distance( c.begin(), c.end() ) );
89
90 BOOST_TEST_MESSAGE( "finished iterator test" );
91
92 BOOST_DEDUCED_TYPENAME C::size_type s = c.size();
93 hide_warning(s);
94 BOOST_DEDUCED_TYPENAME C::size_type s2 = c.max_size();
95 hide_warning(s2);
96 c.push_back( new T );
97 std::size_t size = 2u;
98 #ifndef BOOST_NO_AUTO_PTR
99 c.push_back( std::auto_ptr<T>( new T ) );
100 ++size;
101 #endif
102 #ifndef BOOST_NO_CXX11_SMART_PTR
103 c.push_back( std::unique_ptr<T>( new T ) );
104 ++size;
105 #endif
106 bool b = c.empty();
107 BOOST_CHECK( !c.empty() );
108 b = is_null( c.begin() );
109 BOOST_CHECK( b == false );
110 BOOST_DEDUCED_TYPENAME C::reference r = c.front();
111 hide_warning(r);
112 BOOST_DEDUCED_TYPENAME C::const_reference cr = c2.front();
113 hide_warning(cr);
114 BOOST_DEDUCED_TYPENAME C::reference r2 = c.back();
115 hide_warning(r2);
116 BOOST_DEDUCED_TYPENAME C::const_reference cr2 = c2.back();
117 hide_warning(cr2);
118 BOOST_TEST_MESSAGE( "finished accessors test" );
119
120 c.push_back( new T );
121 ++size;
122 BOOST_CHECK_EQUAL( c.size(), size );
123
124 c.pop_back();
125 BOOST_CHECK( !c.empty() );
126 c.insert( c.end(), new T );
127 #ifndef BOOST_NO_AUTO_PTR
128 std::auto_ptr<T> ap(new T);
129 c.insert( c.end(), ap );
130 ++size;
131 #endif
132 #ifndef BOOST_NO_CXX11_SMART_PTR
133 std::unique_ptr<T> up( new T );
134 c.insert( c.end(), std::move( up ) );
135 ++size;
136 #endif
137 BOOST_CHECK_EQUAL( c.size(), size );
138
139 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
140 #else
141 c.insert( c.end(), c3 );
142 #endif
143 c3.insert( c3.end(), c.begin(), c.end() );
144 c.erase( c.begin() );
145 c3.erase( c3.begin(), c3.end() );
146 c3.erase( boost::make_iterator_range(c3) );
147 BOOST_CHECK( c3.empty() );
148 BOOST_CHECK( !c.empty() );
149 c.swap( c3 );
150 BOOST_CHECK( !c3.empty() );
151 c3.clear();
152 BOOST_CHECK( c3.empty() );
153 C c4;
154 c4.swap(c3);
155 #ifdef BOOST_NO_SFINAE
156 #else
157 swap(c4,c3);
158 #endif
159 BOOST_TEST_MESSAGE( "finished modifiers test" );
160
161 c.push_back( new T ); c.push_back( new T ); c.push_back( new T );
162 typedef BOOST_DEDUCED_TYPENAME C::auto_type auto_type;
163
164 #ifdef BOOST_NO_SFINAE
165 #else
166 auto_type ptr = c.release( c.begin() );
167 #endif
168 #ifndef BOOST_NO_AUTO_PTR
169 std::auto_ptr<C> ap2 = c.release();
170 #else
171 std::unique_ptr<C> up2 = c.release();
172 #endif
173 c = c2.clone();
174 BOOST_CHECK( !c.empty() );
175 auto_type ptr2 = c.replace( c.begin(), new T );
176 #ifndef BOOST_NO_AUTO_PTR
177 ptr2 = c.replace( c.begin(), std::auto_ptr<T>( new T ) );
178 #endif
179 #ifndef BOOST_NO_CXX11_SMART_PTR
180 ptr2 = c.replace( c.begin(), std::unique_ptr<T>( new T ) );
181 #endif
182 BOOST_TEST_MESSAGE( "finished release/clone/replace test" );
183
184 c3.push_back( new T );
185 c3.push_back( new T );
186 c3.push_back( new T );
187 c. BOOST_NESTED_TEMPLATE transfer<C>( c.begin(), c3.begin(), c3 );
188 c. BOOST_NESTED_TEMPLATE transfer<C>( c.end(), c3.begin(), c3.end(), c3 );
189 #ifdef BOOST_NO_SFINAE
190 #else
191 c. BOOST_NESTED_TEMPLATE transfer<C>( c.end(), boost::make_iterator_range( c3 ), c3 );
192 BOOST_CHECK( c3.empty() );
193 BOOST_CHECK( !c.empty() );
194 #endif
195 c3. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(), c );
196 BOOST_CHECK( !c3.empty() );
197 BOOST_CHECK( c.empty() );
198 BOOST_TEST_MESSAGE( "finished transfer test" );
199
200 c3.resize( 0u );
201 BOOST_CHECK( c3.empty() );
202 c3.resize( 10u );
203 BOOST_CHECK_EQUAL( c3.size(), 10u );
204 c3.resize( 12u, &*c3.begin() );
205 BOOST_CHECK_EQUAL( c3.size(), 12u );
206 BOOST_TEST_MESSAGE( "finished resize test" );
207
208 }
209
210
211
212 template< class CDerived, class CBase, class T >
test_transfer()213 void test_transfer()
214 {
215 BOOST_TEST_MESSAGE( "starting transfer test" );
216 CDerived from;
217 CBase to;
218
219 set_capacity<CDerived>()( from );
220 set_capacity<CBase>()( to );
221
222 from.push_back( new T );
223 from.push_back( new T );
224 to. BOOST_NESTED_TEMPLATE transfer<CDerived>( to.end(), from );
225 BOOST_TEST_MESSAGE( "finished transfer test" );
226 }
227
228
229
230 #include <boost/assign/list_inserter.hpp>
231 #include <iostream>
232
233 template< class Compare, class C >
is_sorted(const C & c)234 bool is_sorted( const C& c )
235 {
236 if( c.size() < 2 )
237 return true;
238
239 typename C::const_iterator prev = c.begin(),
240 e = c.end(),
241 next = prev;
242 Compare pred;
243 for( ; next != e ; )
244 {
245 prev = next;
246 ++next;
247
248 if( next == c.end() )
249 return true;
250
251 if( !pred(*prev,*next) )
252 return false;
253 }
254 return true;
255 }
256
257
258
259
260 struct equal_to_int
261 {
262 int i_;
263
equal_to_intequal_to_int264 equal_to_int( int i ) : i_(i)
265 { }
266
operator ()equal_to_int267 bool operator()( int i ) const
268 {
269 return i_ == i;
270 }
271 };
272
273
274 template< class IntContainer >
random_access_algorithms_test()275 void random_access_algorithms_test()
276 {
277 BOOST_TEST_MESSAGE( "starting random accessors algorithms test" );
278
279 IntContainer c;
280 set_capacity<IntContainer>()( c );
281 assign::push_back( c )
282 ( new int(1) )
283 ( new int(3) )
284 ( new int(6) )
285 ( new int(7) )
286 ( new int(2) )
287 ( new int(2) )
288 ( new int(0) )
289 ( new int(6) )
290 ( new int(3) );
291 c.sort();
292 BOOST_CHECK( is_sorted< std::less_equal<int> >( c ) );
293 BOOST_CHECK_EQUAL( c.size(), 9u );
294
295 c.unique();
296 BOOST_CHECK_EQUAL( c.size(), 6u );
297 #ifdef PTR_LIST_TEST
298 BOOST_CHECK( c.front() == 0 );
299 BOOST_CHECK( c.back() == 7 );
300 #else
301 BOOST_CHECK( c[0] == 0 );
302 BOOST_CHECK( c[1] == 1 );
303 BOOST_CHECK( c[2] == 2 );
304 BOOST_CHECK( c[3] == 3 );
305 BOOST_CHECK( c[4] == 6 );
306 BOOST_CHECK( c[5] == 7 );
307 #endif
308
309 c.erase_if( equal_to_int(1) );
310 BOOST_CHECK_EQUAL( c.size(), 5u );
311 #ifdef PTR_LIST_TEST
312 BOOST_CHECK_EQUAL( c.front(), 0 );
313 #else
314 BOOST_CHECK_EQUAL( c[0], 0 );
315 BOOST_CHECK_EQUAL( c[1], 2 );
316 #endif
317
318 c.erase_if( equal_to_int(7) );
319 BOOST_CHECK_EQUAL( c.size(), 4u );
320 BOOST_CHECK_EQUAL( c.back(), 6 );
321
322 // C = [0,2,3,6]
323
324 IntContainer c2;
325 set_capacity<IntContainer>()( c2 );
326 assign::push_back( c2 )
327 ( new int(-1) )
328 ( new int(1) )
329 ( new int(4) )
330 ( new int(5) )
331 ( new int(7) );
332 BOOST_CHECK( c2.size() == 5u );
333 c.merge( c2 );
334 BOOST_CHECK( c2.empty() );
335 BOOST_CHECK( c.size() == 9u );
336 BOOST_CHECK( is_sorted< std::less_equal<int> >( c ) );
337 BOOST_TEST_MESSAGE( "finished random accessors algorithms test" );
338 }
339
340 #if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
341 #pragma GCC diagnostic pop
342 #endif
343