]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Bimap |
2 | // | |
3 | // Copyright (c) 2006-2007 Matias Capeletto | |
4 | // | |
5 | // Distributed under the Boost Software License, Version 1.0. | |
6 | // (See accompanying file LICENSE_1_0.txt or copy at | |
7 | // http://www.boost.org/LICENSE_1_0.txt) | |
8 | ||
9 | #ifndef LIBS_BIMAP_TEST_BIMAP_TEST_HPP | |
10 | #define LIBS_BIMAP_TEST_BIMAP_TEST_HPP | |
11 | ||
12 | #if defined(_MSC_VER) | |
13 | #pragma once | |
14 | #endif | |
15 | ||
16 | #include <boost/config.hpp> | |
17 | ||
18 | // std | |
19 | #include <cassert> | |
20 | #include <algorithm> | |
21 | #include <iterator> | |
22 | ||
23 | #include <boost/lambda/lambda.hpp> | |
24 | #include <boost/static_assert.hpp> | |
25 | #include <boost/type_traits/is_same.hpp> | |
26 | #include <boost/utility.hpp> | |
11fdf7f2 | 27 | #include <boost/next_prior.hpp> |
7c673cae FG |
28 | |
29 | template< class Container, class Data > | |
30 | void test_container(Container & c, const Data & d) | |
31 | { | |
32 | assert( d.size() > 2 ); | |
33 | ||
34 | c.clear(); | |
35 | ||
20effc67 TL |
36 | BOOST_TEST( c.size() == 0 ); |
37 | BOOST_TEST( c.empty() ); | |
7c673cae FG |
38 | |
39 | c.insert( *d.begin() ); | |
40 | ||
41 | c.insert( ++d.begin(),d.end() ); | |
42 | ||
20effc67 | 43 | BOOST_TEST( c.size() == d.size() ); |
7c673cae | 44 | |
20effc67 TL |
45 | BOOST_TEST( c.size() <= c.max_size() ); |
46 | BOOST_TEST( ! c.empty() ); | |
7c673cae FG |
47 | |
48 | c.erase( c.begin() ); | |
49 | ||
20effc67 | 50 | BOOST_TEST( c.size() == d.size() - 1 ); |
7c673cae FG |
51 | |
52 | c.erase( c.begin(), c.end() ); | |
53 | ||
20effc67 | 54 | BOOST_TEST( c.empty() ); |
7c673cae FG |
55 | |
56 | c.insert( *d.begin() ); | |
57 | ||
20effc67 | 58 | BOOST_TEST( c.size() == 1 ); |
7c673cae FG |
59 | |
60 | c.insert( c.begin(), *(++d.begin()) ); | |
61 | ||
20effc67 | 62 | BOOST_TEST( c.size() == 2 ); |
7c673cae | 63 | |
20effc67 | 64 | BOOST_TEST( c.begin() != c.end() ); |
7c673cae FG |
65 | } |
66 | ||
67 | template< class Container, class Data > | |
68 | void test_sequence_container(Container & c, const Data & d) | |
69 | { | |
70 | assert( d.size() > 2 ); | |
71 | ||
72 | c.clear(); | |
73 | ||
20effc67 TL |
74 | BOOST_TEST( c.size() == 0 ); |
75 | BOOST_TEST( c.empty() ); | |
7c673cae FG |
76 | |
77 | c.push_front( * d.begin() ); | |
78 | c.push_back ( *(++d.begin()) ); | |
79 | ||
20effc67 TL |
80 | BOOST_TEST( c.front() == * c.begin() ); |
81 | BOOST_TEST( c.back () == *(++c.begin()) ); | |
7c673cae | 82 | |
20effc67 | 83 | BOOST_TEST( c.size() == 2 ); |
7c673cae | 84 | |
20effc67 TL |
85 | BOOST_TEST( c.size() <= c.max_size() ); |
86 | BOOST_TEST( ! c.empty() ); | |
7c673cae FG |
87 | |
88 | c.erase( c.begin() ); | |
89 | ||
20effc67 | 90 | BOOST_TEST( c.size() == 1 ); |
7c673cae FG |
91 | |
92 | c.insert( c.begin(), *(++d.begin()) ); | |
93 | ||
94 | c.erase( c.begin(), c.end() ); | |
95 | ||
20effc67 | 96 | BOOST_TEST( c.empty() ); |
7c673cae FG |
97 | |
98 | c.push_front( *d.begin() ); | |
99 | ||
20effc67 | 100 | BOOST_TEST( c.size() == 1 ); |
7c673cae | 101 | |
20effc67 | 102 | BOOST_TEST( c.begin() != c.end() ); |
7c673cae FG |
103 | |
104 | c.clear(); | |
20effc67 | 105 | BOOST_TEST( c.empty() ); |
7c673cae FG |
106 | |
107 | // assign | |
108 | ||
109 | c.assign(d.begin(),d.end()); | |
20effc67 TL |
110 | BOOST_TEST( c.size() == d.size() ); |
111 | BOOST_TEST( std::equal( c.begin(), c.end(), d.begin() ) ); | |
7c673cae FG |
112 | |
113 | c.assign(d.size(),*d.begin()); | |
20effc67 TL |
114 | BOOST_TEST( c.size() == d.size() ); |
115 | BOOST_TEST( *c.begin() == *d.begin() ); | |
7c673cae FG |
116 | |
117 | // Check insert(IterPos,InputIter,InputIter) | |
118 | ||
119 | c.clear(); | |
120 | c.insert( c.begin(), d.begin(), d.end() ); | |
121 | c.insert( boost::next(c.begin(),2), d.begin(), d.end() ); | |
122 | ||
20effc67 | 123 | BOOST_TEST( std::equal( boost::next(c.begin(),2) |
7c673cae FG |
124 | , boost::next(c.begin(),2+d.size()) , d.begin() ) ); |
125 | ||
126 | // Check resize | |
127 | ||
128 | c.clear() ; | |
129 | c.resize(4,*d.begin()); | |
20effc67 TL |
130 | BOOST_TEST( c.size() == 4 ); |
131 | BOOST_TEST( *c.begin() == *d.begin() ) ; | |
132 | ||
133 | BOOST_TEST( c == c ); | |
134 | BOOST_TEST( ! ( c != c ) ); | |
135 | BOOST_TEST( ! ( c < c ) ); | |
136 | BOOST_TEST( ( c <= c ) ); | |
137 | BOOST_TEST( ! ( c > c ) ); | |
138 | BOOST_TEST( ( c >= c ) ); | |
7c673cae FG |
139 | } |
140 | ||
141 | template< class Container, class Data > | |
142 | void test_vector_container(Container & c, const Data & d) | |
143 | { | |
144 | assert( d.size() > 2 ); | |
145 | ||
146 | c.clear() ; | |
147 | c.reserve(2) ; | |
20effc67 | 148 | BOOST_TEST( c.capacity() >= 2 ) ; |
7c673cae | 149 | c.assign(d.begin(),d.end()); |
20effc67 | 150 | BOOST_TEST( c.capacity() >= c.size() ) ; |
7c673cae | 151 | |
20effc67 TL |
152 | BOOST_TEST( c[0] == *d.begin() ) ; |
153 | BOOST_TEST( c.at(1) == *boost::next(d.begin()) ); | |
7c673cae FG |
154 | |
155 | test_sequence_container(c,d) ; | |
156 | } | |
157 | ||
158 | template< class Container, class Data > | |
159 | void test_associative_container(Container & c, const Data & d) | |
160 | { | |
161 | assert( d.size() > 2 ); | |
162 | ||
163 | c.clear(); | |
164 | c.insert(d.begin(),d.end()); | |
165 | ||
166 | for( typename Data::const_iterator di = d.begin(), de = d.end(); | |
167 | di != de; ++di ) | |
168 | { | |
20effc67 | 169 | BOOST_TEST( c.find(*di) != c.end() ); |
7c673cae FG |
170 | } |
171 | ||
172 | typename Data::const_iterator da = d.begin(); | |
173 | typename Data::const_iterator db = ++d.begin(); | |
174 | ||
175 | c.erase(*da); | |
176 | ||
20effc67 | 177 | BOOST_TEST( c.size() == d.size()-1 ); |
7c673cae | 178 | |
20effc67 TL |
179 | BOOST_TEST( c.count(*da) == 0 ); |
180 | BOOST_TEST( c.count(*db) == 1 ); | |
7c673cae | 181 | |
20effc67 TL |
182 | BOOST_TEST( c.find(*da) == c.end() ); |
183 | BOOST_TEST( c.find(*db) != c.end() ); | |
7c673cae | 184 | |
20effc67 | 185 | BOOST_TEST( c.equal_range(*db).first != c.end() ); |
7c673cae FG |
186 | |
187 | c.clear(); | |
188 | ||
20effc67 | 189 | BOOST_TEST( c.equal_range(*da).first == c.end() ); |
7c673cae FG |
190 | } |
191 | ||
192 | ||
193 | template< class Container > | |
194 | void test_mapped_container(Container &) | |
195 | { | |
196 | typedef BOOST_DEDUCED_TYPENAME Container:: value_type value_type ; | |
197 | typedef BOOST_DEDUCED_TYPENAME Container:: key_type key_type ; | |
198 | typedef BOOST_DEDUCED_TYPENAME Container:: data_type data_type ; | |
199 | typedef BOOST_DEDUCED_TYPENAME Container::mapped_type mapped_type ; | |
200 | ||
201 | typedef BOOST_DEDUCED_TYPENAME | |
202 | boost::is_same< key_type | |
203 | , BOOST_DEDUCED_TYPENAME value_type::first_type | |
204 | >::type test_key_type; | |
205 | BOOST_STATIC_ASSERT(test_key_type::value); | |
206 | ||
207 | typedef BOOST_DEDUCED_TYPENAME | |
208 | boost::is_same< data_type | |
209 | , BOOST_DEDUCED_TYPENAME value_type::second_type | |
210 | >::type test_data_type; | |
211 | BOOST_STATIC_ASSERT(test_data_type::value); | |
212 | ||
213 | typedef BOOST_DEDUCED_TYPENAME | |
214 | boost::is_same< mapped_type | |
215 | , BOOST_DEDUCED_TYPENAME value_type::second_type | |
216 | >::type test_mapped_type; | |
217 | BOOST_STATIC_ASSERT(test_mapped_type::value); | |
218 | } | |
219 | ||
220 | template< class Container, class Data > | |
221 | void test_pair_associative_container(Container & c, const Data & d) | |
222 | { | |
223 | test_mapped_container(c); | |
224 | ||
225 | assert( d.size() > 2 ); | |
226 | ||
227 | c.clear(); | |
228 | c.insert(d.begin(),d.end()); | |
229 | ||
230 | for( typename Data::const_iterator di = d.begin(), de = d.end(); | |
231 | di != de; ++di ) | |
232 | { | |
20effc67 | 233 | BOOST_TEST( c.find(di->first) != c.end() ); |
7c673cae FG |
234 | } |
235 | ||
236 | typename Data::const_iterator da = d.begin(); | |
237 | typename Data::const_iterator db = ++d.begin(); | |
238 | ||
239 | c.erase(da->first); | |
240 | ||
20effc67 | 241 | BOOST_TEST( c.size() == d.size()-1 ); |
7c673cae | 242 | |
20effc67 TL |
243 | BOOST_TEST( c.count(da->first) == 0 ); |
244 | BOOST_TEST( c.count(db->first) == 1 ); | |
7c673cae | 245 | |
20effc67 TL |
246 | BOOST_TEST( c.find(da->first) == c.end() ); |
247 | BOOST_TEST( c.find(db->first) != c.end() ); | |
7c673cae | 248 | |
20effc67 | 249 | BOOST_TEST( c.equal_range(db->first).first != c.end() ); |
7c673cae FG |
250 | |
251 | c.clear(); | |
252 | ||
20effc67 | 253 | BOOST_TEST( c.equal_range(da->first).first == c.end() ); |
7c673cae FG |
254 | } |
255 | ||
256 | ||
257 | template< class Container, class Data > | |
258 | void test_simple_ordered_associative_container_equality(Container & c, const Data & d) | |
259 | { | |
20effc67 TL |
260 | BOOST_TEST( std::equal( c. begin(), c. end(), d. begin() ) ); |
261 | BOOST_TEST( std::equal( c.rbegin(), c.rend(), d.rbegin() ) ); | |
7c673cae | 262 | |
20effc67 TL |
263 | BOOST_TEST( c.lower_bound( *d.begin() ) == c.begin() ); |
264 | BOOST_TEST( c.upper_bound( *d.begin() ) == ++c.begin() ); | |
7c673cae FG |
265 | } |
266 | ||
267 | template< class Container, class Data > | |
268 | void test_simple_ordered_associative_container(Container & c, const Data & d) | |
269 | { | |
270 | assert( d.size() > 2 ); | |
271 | ||
272 | c.clear(); | |
273 | c.insert(d.begin(),d.end()); | |
274 | ||
275 | for( typename Data::const_iterator di = d.begin(), de = d.end(); | |
276 | di != de; ++di ) | |
277 | { | |
278 | typename Container::const_iterator ci = c.find(*di); | |
20effc67 | 279 | BOOST_TEST( ci != c.end() ); |
7c673cae | 280 | |
20effc67 TL |
281 | BOOST_TEST( ! c.key_comp()(*ci,*di) ); |
282 | BOOST_TEST( ! c.value_comp()(*ci,*di) ); | |
7c673cae FG |
283 | } |
284 | ||
285 | test_simple_ordered_associative_container_equality(c, d); | |
286 | ||
287 | const Container & cr = c; | |
288 | ||
289 | test_simple_ordered_associative_container_equality(cr, d); | |
290 | ||
20effc67 TL |
291 | BOOST_TEST( c == c ); |
292 | BOOST_TEST( ! ( c != c ) ); | |
293 | BOOST_TEST( ! ( c < c ) ); | |
294 | BOOST_TEST( ( c <= c ) ); | |
295 | BOOST_TEST( ! ( c > c ) ); | |
296 | BOOST_TEST( ( c >= c ) ); | |
7c673cae FG |
297 | |
298 | /* | |
20effc67 | 299 | BOOST_TEST( c.range( *c.begin() <= ::boost::lambda::_1, |
7c673cae FG |
300 | ::boost::lambda::_1 <= *(++c.begin()) ). |
301 | first == c.begin() | |
302 | ); | |
303 | */ | |
304 | } | |
305 | ||
306 | template< class Container, class Data > | |
307 | void test_simple_unordered_associative_container(Container & c, const Data & d) | |
308 | { | |
309 | c.clear(); | |
310 | c.insert( d.begin(), d.end() ); | |
311 | ||
20effc67 TL |
312 | BOOST_TEST( c.bucket_count() * c.max_load_factor() >= d.size() ); |
313 | BOOST_TEST( c.max_bucket_count() >= c.bucket_count() ); | |
7c673cae FG |
314 | |
315 | for( typename Data::const_iterator di = d.begin(), de = d.end() ; | |
316 | di != de ; ++di ) | |
317 | { | |
318 | // non const | |
319 | { | |
320 | typename Container::size_type nb = c.bucket(*c.find(*di)); | |
321 | ||
20effc67 | 322 | BOOST_TEST( c.begin(nb) != c.end(nb) ); |
7c673cae FG |
323 | } |
324 | ||
325 | // const | |
326 | { | |
327 | const Container & const_c = c; | |
328 | ||
20effc67 | 329 | BOOST_TEST( |
7c673cae FG |
330 | const_c.bucket_size(const_c.bucket(*di)) == 1 |
331 | ); | |
332 | ||
333 | typename Container::size_type nb = | |
334 | const_c.bucket(*const_c.find(*di)); | |
335 | ||
20effc67 | 336 | BOOST_TEST( |
7c673cae FG |
337 | const_c.begin(nb) != const_c.end(nb) |
338 | ); | |
339 | } | |
340 | } | |
341 | ||
342 | ||
20effc67 | 343 | BOOST_TEST( c.load_factor() < c.max_load_factor() ); |
7c673cae FG |
344 | |
345 | c.max_load_factor(0.75); | |
346 | ||
20effc67 | 347 | BOOST_TEST( c.max_load_factor() == 0.75 ); |
7c673cae FG |
348 | |
349 | c.rehash(10); | |
350 | } | |
351 | ||
352 | ||
353 | template< class Container, class Data > | |
354 | void test_pair_ordered_associative_container_equality(Container & c, const Data & d) | |
355 | { | |
20effc67 TL |
356 | BOOST_TEST( std::equal( c. begin(), c. end(), d. begin() ) ); |
357 | BOOST_TEST( std::equal( c.rbegin(), c.rend(), d.rbegin() ) ); | |
7c673cae | 358 | |
20effc67 TL |
359 | BOOST_TEST( c.lower_bound( d.begin()->first ) == c.begin() ); |
360 | BOOST_TEST( c.upper_bound( d.begin()->first ) == ++c.begin() ); | |
7c673cae FG |
361 | } |
362 | ||
363 | template< class Container, class Data > | |
364 | void test_pair_ordered_associative_container(Container & c, const Data & d) | |
365 | { | |
366 | assert( d.size() > 2 ); | |
367 | ||
368 | c.clear(); | |
369 | c.insert(d.begin(),d.end()); | |
370 | ||
371 | for( typename Container::const_iterator ci = c.begin(), ce = c.end(); | |
372 | ci != ce; ++ci ) | |
373 | { | |
374 | typename Data::const_iterator di = d.find(ci->first); | |
20effc67 TL |
375 | BOOST_TEST( di != d.end() ); |
376 | BOOST_TEST( ! c.key_comp()(di->first,ci->first) ); | |
377 | BOOST_TEST( ! c.value_comp()(*ci,*di) ); | |
7c673cae FG |
378 | } |
379 | ||
380 | test_pair_ordered_associative_container_equality(c, d); | |
381 | ||
382 | const Container & cr = c; | |
383 | ||
384 | test_pair_ordered_associative_container_equality(cr, d); | |
385 | ||
20effc67 | 386 | BOOST_TEST( c.range( c.begin()->first <= ::boost::lambda::_1, |
7c673cae FG |
387 | ::boost::lambda::_1 <= (++c.begin())->first ). |
388 | first == c.begin() | |
389 | ); | |
390 | } | |
391 | ||
392 | ||
393 | template< class Container, class Data > | |
394 | void test_pair_unordered_associative_container(Container & c, const Data & d) | |
395 | { | |
396 | c.clear(); | |
397 | c.insert( d.begin(), d.end() ); | |
398 | ||
20effc67 TL |
399 | BOOST_TEST( c.bucket_count() * c.max_load_factor() >= d.size() ); |
400 | BOOST_TEST( c.max_bucket_count() >= c.bucket_count() ); | |
7c673cae FG |
401 | |
402 | for( typename Data::const_iterator di = d.begin(), de = d.end() ; | |
403 | di != de ; ++di ) | |
404 | { | |
405 | // non const | |
406 | { | |
407 | typename Container::size_type nb = | |
408 | c.bucket(c.find(di->first)->first); | |
409 | ||
20effc67 | 410 | BOOST_TEST( c.begin(nb) != c.end(nb) ); |
7c673cae FG |
411 | } |
412 | ||
413 | // const | |
414 | { | |
415 | const Container & const_c = c; | |
416 | ||
1e59de90 TL |
417 | #if !defined(_M_IX86) // fails on Windows x86 (collisions?) |
418 | ||
419 | BOOST_TEST_EQ( const_c.bucket_size(const_c.bucket(di->first)), 1 ); | |
420 | ||
421 | #endif | |
7c673cae FG |
422 | |
423 | typename Container::size_type nb = | |
424 | const_c.bucket(const_c.find(di->first)->first); | |
425 | ||
20effc67 | 426 | BOOST_TEST( const_c.begin(nb) != const_c.end(nb) ); |
7c673cae FG |
427 | } |
428 | } | |
429 | ||
430 | ||
20effc67 | 431 | BOOST_TEST( c.load_factor() < c.max_load_factor() ); |
7c673cae FG |
432 | |
433 | c.max_load_factor(0.75); | |
434 | ||
20effc67 | 435 | BOOST_TEST( c.max_load_factor() == 0.75 ); |
7c673cae FG |
436 | |
437 | c.rehash(10); | |
438 | } | |
439 | ||
440 | ||
441 | template< class Container, class Data > | |
442 | void test_unique_container(Container & c, Data & d) | |
443 | { | |
444 | c.clear(); | |
445 | c.insert(d.begin(),d.end()); | |
446 | c.insert(*d.begin()); | |
20effc67 | 447 | BOOST_TEST( c.size() == d.size() ); |
7c673cae FG |
448 | } |
449 | ||
450 | template< class Container, class Data > | |
451 | void test_non_unique_container(Container & c, Data & d) | |
452 | { | |
453 | c.clear(); | |
454 | c.insert(d.begin(),d.end()); | |
455 | c.insert(*d.begin()); | |
20effc67 | 456 | BOOST_TEST( c.size() == (d.size()+1) ); |
7c673cae FG |
457 | } |
458 | ||
459 | ||
460 | ||
461 | template< class Bimap, class Data, class LeftData, class RightData > | |
462 | void test_basic_bimap( Bimap & b, | |
463 | const Data & d, | |
464 | const LeftData & ld, const RightData & rd) | |
465 | { | |
466 | using namespace boost::bimaps; | |
467 | ||
468 | test_container(b,d); | |
469 | ||
20effc67 TL |
470 | BOOST_TEST( & b.left == & b.template by<member_at::left >() ); |
471 | BOOST_TEST( & b.right == & b.template by<member_at::right>() ); | |
7c673cae FG |
472 | |
473 | test_container(b.left , ld); | |
474 | test_container(b.right, rd); | |
475 | } | |
476 | ||
477 | template< class LeftTag, class RightTag, class Bimap, class Data > | |
478 | void test_tagged_bimap(Bimap & b, | |
479 | const Data & d) | |
480 | { | |
481 | using namespace boost::bimaps; | |
482 | ||
20effc67 TL |
483 | BOOST_TEST( &b.left == & b.template by<LeftTag >() ); |
484 | BOOST_TEST( &b.right == & b.template by<RightTag>() ); | |
7c673cae FG |
485 | |
486 | b.clear(); | |
487 | b.insert( *d.begin() ); | |
488 | ||
20effc67 | 489 | BOOST_TEST( |
7c673cae FG |
490 | b.begin()->template get<LeftTag>() == |
491 | b.template by<RightTag>().begin()->template get<LeftTag>() | |
492 | ); | |
493 | ||
20effc67 | 494 | BOOST_TEST( |
7c673cae FG |
495 | b.begin()->template get<RightTag>() == |
496 | b.template by<LeftTag>().begin()->template get<RightTag>() | |
497 | ); | |
498 | ||
499 | // const test | |
500 | { | |
501 | ||
502 | const Bimap & bc = b; | |
503 | ||
20effc67 TL |
504 | BOOST_TEST( &bc.left == & bc.template by<LeftTag>() ); |
505 | BOOST_TEST( &bc.right == & bc.template by<RightTag>() ); | |
7c673cae | 506 | |
20effc67 | 507 | BOOST_TEST( bc.begin()->template get<LeftTag>() == |
7c673cae FG |
508 | bc.template by<RightTag>().begin()->template get<LeftTag>() ); |
509 | ||
20effc67 | 510 | BOOST_TEST( bc.begin()->template get<RightTag>() == |
7c673cae FG |
511 | bc.template by<LeftTag>().begin()->template get<RightTag>() ); |
512 | } | |
513 | } | |
514 | ||
515 | ||
516 | template< class Bimap, class Data, class LeftData, class RightData > | |
517 | void test_set_set_bimap(Bimap & b, | |
518 | const Data & d, | |
519 | const LeftData & ld, const RightData & rd) | |
520 | { | |
521 | using namespace boost::bimaps; | |
522 | ||
523 | test_basic_bimap(b,d,ld,rd); | |
524 | ||
525 | test_associative_container(b,d); | |
526 | test_simple_ordered_associative_container(b,d); | |
527 | ||
528 | test_pair_associative_container(b.left, ld); | |
529 | test_pair_ordered_associative_container(b.left, ld); | |
530 | test_unique_container(b.left, ld); | |
531 | ||
532 | test_pair_associative_container(b.right, rd); | |
533 | test_pair_ordered_associative_container(b.right, rd); | |
534 | test_unique_container(b.right, rd); | |
535 | ||
536 | } | |
537 | ||
538 | ||
539 | template< class Bimap, class Data, class LeftData, class RightData > | |
540 | void test_multiset_multiset_bimap(Bimap & b, | |
541 | const Data & d, | |
542 | const LeftData & ld, const RightData & rd) | |
543 | { | |
544 | using namespace boost::bimaps; | |
545 | ||
546 | test_basic_bimap(b,d,ld,rd); | |
547 | test_associative_container(b,d); | |
548 | test_simple_ordered_associative_container(b,d); | |
549 | ||
550 | test_pair_associative_container(b.left, ld); | |
551 | test_pair_ordered_associative_container(b.left, ld); | |
552 | test_non_unique_container(b.left, ld); | |
553 | ||
554 | test_pair_associative_container(b.right, rd); | |
555 | test_pair_ordered_associative_container(b.right, rd); | |
556 | test_non_unique_container(b.right, rd); | |
557 | } | |
558 | ||
559 | template< class Bimap, class Data, class LeftData, class RightData > | |
560 | void test_unordered_set_unordered_multiset_bimap(Bimap & b, | |
561 | const Data & d, | |
562 | const LeftData & ld, | |
563 | const RightData & rd) | |
564 | { | |
565 | using namespace boost::bimaps; | |
566 | ||
567 | test_basic_bimap(b,d,ld,rd); | |
568 | test_associative_container(b,d); | |
569 | test_simple_unordered_associative_container(b,d); | |
570 | ||
571 | test_pair_associative_container(b.left, ld); | |
572 | test_pair_unordered_associative_container(b.left, ld); | |
573 | test_unique_container(b.left, ld); | |
574 | ||
575 | test_pair_associative_container(b.right, rd); | |
576 | test_pair_unordered_associative_container(b.right, rd); | |
577 | ||
578 | // Caution, this side is a non unique container, but the other side is a | |
579 | // unique container so, the overall bimap is a unique one. | |
580 | test_unique_container(b.right, rd); | |
581 | } | |
582 | ||
583 | template< class Bimap, class Data> | |
584 | void test_bimap_init_copy_swap(const Data&d) | |
585 | { | |
586 | Bimap b1(d.begin(),d.end()); | |
587 | Bimap b2( b1 ); | |
20effc67 | 588 | BOOST_TEST( b1 == b2 ); |
7c673cae FG |
589 | |
590 | b2.clear(); | |
591 | b2 = b1; | |
20effc67 | 592 | BOOST_TEST( b2 == b1 ); |
7c673cae FG |
593 | |
594 | b2.clear(); | |
595 | b2.left = b1.left; | |
20effc67 | 596 | BOOST_TEST( b2 == b1 ); |
7c673cae FG |
597 | |
598 | b2.clear(); | |
599 | b2.right = b1.right; | |
20effc67 | 600 | BOOST_TEST( b2 == b1 ); |
7c673cae FG |
601 | |
602 | b1.clear(); | |
603 | b2.swap(b1); | |
20effc67 | 604 | BOOST_TEST( b2.empty() && !b1.empty() ); |
7c673cae FG |
605 | |
606 | b1.left.swap( b2.left ); | |
20effc67 | 607 | BOOST_TEST( b1.empty() && !b2.empty() ); |
7c673cae FG |
608 | |
609 | b1.right.swap( b2.right ); | |
20effc67 | 610 | BOOST_TEST( b2.empty() && !b1.empty() ); |
7c673cae FG |
611 | } |
612 | ||
613 | #endif // LIBS_BIMAP_TEST_BIMAP_TEST_HPP | |
614 |