tests/test-hdr/map/hdr_striped_map.h

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
   5
   6     Source code repo: http://github.com/khizmax/libcds/
   7     Download: http://sourceforge.net/projects/libcds/files/
   8
   9     Redistribution and use in source and binary forms, with or without
  10     modification, are permitted provided that the following conditions are met:
  11
  12     * Redistributions of source code must retain the above copyright notice, this
  13       list of conditions and the following disclaimer.
  14
  15     * Redistributions in binary form must reproduce the above copyright notice,
  16       this list of conditions and the following disclaimer in the documentation
  17       and/or other materials provided with the distribution.
  18
  19     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  23     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #ifndef CDSTEST_HDR_STRIPED_MAP_H
  32 #define CDSTEST_HDR_STRIPED_MAP_H
  33 #include "size_check.h"
  34
  35 #include "cppunit/cppunit_proxy.h"
  36 #include <cds/os/timer.h>
  37 #include <cds/opt/hash.h>
  38 #include <functional>   // ref
  39
  40 namespace cds { namespace container {}}
  41
  42 namespace map {
  43     using misc::check_size;
  44
  45     namespace cc = cds::container;
  46     namespace co = cds::opt;
  47
  48     class StripedMapHdrTest: public CppUnitMini::TestCase
  49     {
  50     public:
  51         typedef int key_type;
  52
  53         struct value_type {
  54             int m_val;
  55
  56             value_type()
  57                 : m_val(0)
  58             {}
  59
  60             value_type( int n )
  61                 : m_val( n )
  62             {}
  63
  64             value_type( value_type&& v )
  65                 : m_val( v.m_val )
  66             {}
  67
  68             value_type( value_type const& v )
  69                 : m_val( v.m_val )
  70             {}
  71
  72             value_type& operator=( value_type const& v )
  73             {
  74                 m_val = v.m_val;
  75                 return *this;
  76             }
  77         };
  78
  79         typedef std::pair<key_type const, value_type> pair_type;
  80
  81         struct less
  82         {
  83             bool operator ()(int v1, int v2 ) const
  84             {
  85                 return v1 < v2;
  86             }
  87         };
  88
  89         struct cmp {
  90             int operator ()(int v1, int v2 ) const
  91             {
  92                 if ( v1 < v2 )
  93                     return -1;
  94                 return v1 > v2 ? 1 : 0;
  95             }
  96         };
  97
  98         struct equal {
  99             bool operator ()(int v1, int v2 ) const
 100             {
 101                 return v1 == v2;
 102             }
 103         };
 104
 105         struct hash_int {
 106             size_t operator()( int i ) const
 107             {
 108                 return co::v::hash<int>()( i );
 109             }
 110         };
 111
 112         struct simple_item_counter {
 113             size_t  m_nCount;
 114
 115             simple_item_counter()
 116                 : m_nCount(0)
 117             {}
 118
 119             size_t operator ++()
 120             {
 121                 return ++m_nCount;
 122             }
 123
 124             size_t operator --()
 125             {
 126                 return --m_nCount;
 127             }
 128
 129             void reset()
 130             {
 131                 m_nCount = 0;
 132             }
 133
 134             operator size_t() const
 135             {
 136                 return m_nCount;
 137             }
 138         };
 139
 140         template <typename Map>
 141         struct insert_functor
 142         {
 143             typedef typename Map::value_type pair_type;
 144
 145             // insert ftor
 146             void operator()( pair_type& item )
 147             {
 148                 item.second.m_val = item.first * 3;
 149             }
 150
 151             // update() ftor
 152             void operator()( bool bNew, pair_type& item )
 153             {
 154                 if ( bNew )
 155                     item.second.m_val = item.first * 2;
 156                 else
 157                     item.second.m_val = item.first * 5;
 158             }
 159         };
 160
 161         struct check_value {
 162             int     m_nExpected;
 163
 164             check_value( int nExpected )
 165                 : m_nExpected( nExpected )
 166             {}
 167
 168             template <typename T>
 169             void operator ()( T& pair )
 170             {
 171                 CPPUNIT_ASSERT_CURRENT( pair.second.m_val == m_nExpected );
 172             }
 173             template <typename T, typename Q>
 174             void operator ()( T& pair, Q )
 175             {
 176                 CPPUNIT_ASSERT_CURRENT( pair.second.m_val == m_nExpected );
 177             }
 178         };
 179
 180         struct extract_functor
 181         {
 182             int *   m_pVal;
 183             void operator()( pair_type const& val )
 184             {
 185                 *m_pVal = val.second.m_val;
 186             }
 187         };
 188
 189         template <class Map>
 190         void test_int_with( Map& m )
 191         {
 192             std::pair<bool, bool> updateResult;
 193
 194             // insert
 195             CPPUNIT_ASSERT( m.empty() );
 196             CPPUNIT_ASSERT( check_size( m, 0 ));
 197             CPPUNIT_ASSERT( !m.contains(25) );
 198             CPPUNIT_ASSERT( m.insert( 25 ) )    ;   // value = 0
 199             CPPUNIT_ASSERT( m.contains(25) );
 200             CPPUNIT_ASSERT( !m.empty() );
 201             CPPUNIT_ASSERT( check_size( m, 1 ));
 202             CPPUNIT_ASSERT( m.contains(25) );
 203
 204             CPPUNIT_ASSERT( !m.insert( 25 ) );
 205             CPPUNIT_ASSERT( !m.empty() );
 206             CPPUNIT_ASSERT( check_size( m, 1 ));
 207
 208             CPPUNIT_ASSERT( !m.contains(10) );
 209             CPPUNIT_ASSERT( m.insert( 10, 10 ) );
 210             CPPUNIT_ASSERT( !m.empty() );
 211             CPPUNIT_ASSERT( check_size( m, 2 ));
 212             CPPUNIT_ASSERT( m.contains(10) );
 213
 214             CPPUNIT_ASSERT( !m.insert( 10, 20 ) );
 215             CPPUNIT_ASSERT( !m.empty() );
 216             CPPUNIT_ASSERT( check_size( m, 2 ));
 217
 218             CPPUNIT_ASSERT( !m.contains(30) );
 219             CPPUNIT_ASSERT( m.insert_with( 30, insert_functor<Map>() ) )    ; // value = 90
 220             CPPUNIT_ASSERT( !m.empty() );
 221             CPPUNIT_ASSERT( check_size( m, 3 ));
 222             CPPUNIT_ASSERT( m.contains(30) );
 223
 224             CPPUNIT_ASSERT( !m.insert_with( 10, insert_functor<Map>() ) );
 225             CPPUNIT_ASSERT( !m.insert_with( 25, insert_functor<Map>() ) );
 226             CPPUNIT_ASSERT( !m.insert_with( 30, insert_functor<Map>() ) );
 227
 228             // update() (new key)
 229             CPPUNIT_ASSERT( !m.contains(27) );
 230             updateResult = m.update(27, insert_functor<Map>(), false);
 231             CPPUNIT_ASSERT(!updateResult.first);
 232             CPPUNIT_ASSERT(!updateResult.second);
 233             CPPUNIT_ASSERT(check_size(m, 3));
 234             CPPUNIT_ASSERT(!m.contains(27));
 235             updateResult = m.update( 27, insert_functor<Map>() ) ;   // value = 54
 236             CPPUNIT_ASSERT( updateResult.first );
 237             CPPUNIT_ASSERT( updateResult.second );
 238             CPPUNIT_ASSERT( check_size( m, 4 ));
 239             CPPUNIT_ASSERT( m.contains(27) );
 240
 241             // find test
 242             check_value chk(10);
 243             CPPUNIT_ASSERT( m.find( 10, std::ref(chk) ));
 244             chk.m_nExpected = 0;
 245             CPPUNIT_ASSERT( m.find( 25, std::ref( chk ) ) );
 246             chk.m_nExpected = 90;
 247             CPPUNIT_ASSERT( m.find( 30, std::ref( chk ) ) );
 248             chk.m_nExpected = 54;
 249             CPPUNIT_ASSERT( m.find( 27, std::ref( chk ) ) );
 250
 251             updateResult = m.update( 10, insert_functor<Map>() ) ;   // value = 50
 252             CPPUNIT_ASSERT( updateResult.first );
 253             CPPUNIT_ASSERT( !updateResult.second );
 254             chk.m_nExpected = 50;
 255             CPPUNIT_ASSERT( m.find( 10, std::ref( chk ) ) );
 256
 257             // erase test
 258             CPPUNIT_ASSERT( !m.contains(100) );
 259             CPPUNIT_ASSERT( !m.erase( 100 )) ;  // not found
 260
 261             CPPUNIT_ASSERT( m.contains(25) );
 262             CPPUNIT_ASSERT( check_size( m, 4 ));
 263             CPPUNIT_ASSERT( m.erase( 25 ));
 264             CPPUNIT_ASSERT( !m.empty() );
 265             CPPUNIT_ASSERT( check_size( m, 3 ));
 266             CPPUNIT_ASSERT( !m.contains(25) );
 267             CPPUNIT_ASSERT( !m.erase( 25 ));
 268
 269             CPPUNIT_ASSERT( !m.contains(258) );
 270             CPPUNIT_ASSERT( m.insert(258))
 271             CPPUNIT_ASSERT( check_size( m, 4 ));
 272             CPPUNIT_ASSERT( m.contains(258) );
 273             CPPUNIT_ASSERT( m.erase( 258 ));
 274             CPPUNIT_ASSERT( !m.empty() );
 275             CPPUNIT_ASSERT( check_size( m, 3 ));
 276             CPPUNIT_ASSERT( !m.contains(258) );
 277             CPPUNIT_ASSERT( !m.erase( 258 ));
 278
 279             int nVal;
 280             extract_functor ext;
 281             ext.m_pVal = &nVal;
 282
 283             CPPUNIT_ASSERT( !m.contains(29) );
 284             CPPUNIT_ASSERT( m.insert(29, 290));
 285             CPPUNIT_ASSERT( check_size( m, 4 ));
 286             CPPUNIT_ASSERT( m.erase( 29, std::ref( ext ) ) );
 287             CPPUNIT_ASSERT( !m.empty() );
 288             CPPUNIT_ASSERT( check_size( m, 3 ));
 289             CPPUNIT_ASSERT( nVal == 290 );
 290             nVal = -1;
 291             CPPUNIT_ASSERT( !m.erase( 29, std::ref( ext ) ) );
 292             CPPUNIT_ASSERT( nVal == -1 );
 293
 294             CPPUNIT_ASSERT( m.erase( 30, std::ref( ext ) ) );
 295             CPPUNIT_ASSERT( !m.empty() );
 296             CPPUNIT_ASSERT( check_size( m, 2 ));
 297             CPPUNIT_ASSERT( nVal == 90 );
 298             nVal = -1;
 299             CPPUNIT_ASSERT( !m.erase( 30, std::ref( ext ) ) );
 300             CPPUNIT_ASSERT( nVal == -1 );
 301
 302             m.clear();
 303             CPPUNIT_ASSERT( m.empty() );
 304             CPPUNIT_ASSERT( check_size( m, 0 ));
 305
 306             // emplace test
 307             CPPUNIT_ASSERT( m.emplace(126) ) ; // key = 126, val = 0
 308             CPPUNIT_ASSERT( m.emplace(137, 731))    ;   // key = 137, val = 731
 309             CPPUNIT_ASSERT( m.emplace( 149, value_type(941) ))   ;   // key = 149, val = 941
 310
 311             CPPUNIT_ASSERT( !m.empty() );
 312             CPPUNIT_ASSERT( check_size( m, 3 ));
 313
 314             chk.m_nExpected = 0;
 315             CPPUNIT_ASSERT( m.find( 126, std::ref(chk) ));
 316             chk.m_nExpected = 731;
 317             CPPUNIT_ASSERT( m.find( 137, std::ref(chk) ));
 318             chk.m_nExpected = 941;
 319             CPPUNIT_ASSERT( m.find( 149, std::ref(chk) ));
 320
 321             CPPUNIT_ASSERT( !m.emplace(126, 621)) ; // already in map
 322             chk.m_nExpected = 0;
 323             CPPUNIT_ASSERT( m.find( 126, std::ref(chk) ));
 324             CPPUNIT_ASSERT( !m.empty() );
 325             CPPUNIT_ASSERT( check_size( m, 3 ));
 326
 327             m.clear();
 328             CPPUNIT_ASSERT( m.empty() );
 329             CPPUNIT_ASSERT( check_size( m, 0 ));
 330         }
 331
 332         template <class Map>
 333         void test_iter( Map& s)
 334         {
 335             typedef typename Map::iterator          iterator;
 336             typedef typename Map::const_iterator    const_iterator;
 337
 338             const int nMaxCount = 500;
 339             for ( int i = 0; i < nMaxCount; ++i ) {
 340                 CPPUNIT_ASSERT( s.insert( i, i * 2 ));
 341             }
 342
 343             int nCount = 0;
 344             for ( iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
 345                 CPPUNIT_ASSERT( it->first * 2 == it->second.m_val );
 346                 CPPUNIT_ASSERT( (*it).first * 2 == (*it).second.m_val );
 347                 it->second.m_val = it->first;
 348                 ++nCount;
 349             }
 350             CPPUNIT_ASSERT( nCount == nMaxCount );
 351
 352             Map const& refSet = s;
 353             nCount = 0;
 354             for ( const_iterator it = refSet.begin(), itEnd = refSet.end(); it != itEnd; ++it ) {
 355                 CPPUNIT_ASSERT( it->first == it->second.m_val );
 356                 CPPUNIT_ASSERT( (*it).first == (*it).second.m_val );
 357                 ++nCount;
 358             }
 359             CPPUNIT_ASSERT( nCount == nMaxCount );
 360         }
 361
 362         template <class Map>
 363         void test_striped()
 364         {
 365             Map m( 30 );
 366             CPPUNIT_ASSERT( m.bucket_count() == 32 );
 367             CPPUNIT_ASSERT( m.lock_count() == 32 );
 368
 369             test_striped_with(m);
 370         }
 371
 372         template <class Map>
 373         void test_striped_with(Map& m)
 374         {
 375             cds::OS::Timer    timer;
 376
 377             test_int_with( m );
 378
 379             // Iterators is not yet supported
 380             //m.clear();
 381             //CPPUNIT_ASSERT( m.empty() );
 382             //CPPUNIT_ASSERT( check_size( m, 0 ));
 383             //test_iter(m);
 384
 385             m.clear();
 386             CPPUNIT_ASSERT( m.empty() );
 387             CPPUNIT_ASSERT( check_size( m, 0 ));
 388
 389             // Resizing test
 390             for ( int i = 0; i < 40000; i++ ) {
 391                 m.insert( i );
 392             }
 393
 394             CPPUNIT_MSG( "   Duration=" << timer.duration() );
 395         }
 396
 397         //*******************************************
 398         // If erase_with && find_with are supported
 399         template <class Map>
 400         void test_int_with2( Map& m )
 401         {
 402             std::pair<bool, bool> updateResult;
 403
 404             // insert
 405             CPPUNIT_ASSERT( m.empty() );
 406             CPPUNIT_ASSERT( check_size( m, 0 ));
 407             CPPUNIT_ASSERT( !m.contains(25) );
 408             CPPUNIT_ASSERT( m.insert( 25 ) )    ;   // value = 0
 409             CPPUNIT_ASSERT( m.contains(25) );
 410             CPPUNIT_ASSERT( !m.empty() );
 411             CPPUNIT_ASSERT( check_size( m, 1 ));
 412             CPPUNIT_ASSERT( m.contains(25) );
 413
 414             CPPUNIT_ASSERT( !m.insert( 25 ) );
 415             CPPUNIT_ASSERT( !m.empty() );
 416             CPPUNIT_ASSERT( check_size( m, 1 ));
 417
 418             CPPUNIT_ASSERT( !m.contains(10, less()) );
 419             CPPUNIT_ASSERT( m.insert( 10, 10 ) );
 420             CPPUNIT_ASSERT( !m.empty() );
 421             CPPUNIT_ASSERT( check_size( m, 2 ));
 422             CPPUNIT_ASSERT( m.contains(10, less()) );
 423
 424             CPPUNIT_ASSERT( !m.insert( 10, 20 ) );
 425             CPPUNIT_ASSERT( !m.empty() );
 426             CPPUNIT_ASSERT( check_size( m, 2 ));
 427
 428             CPPUNIT_ASSERT( !m.contains(30) );
 429             CPPUNIT_ASSERT( m.insert_with( 30, insert_functor<Map>() ) )    ; // value = 90
 430             CPPUNIT_ASSERT( !m.empty() );
 431             CPPUNIT_ASSERT( check_size( m, 3 ));
 432             CPPUNIT_ASSERT( m.contains(30) );
 433
 434             CPPUNIT_ASSERT( !m.insert_with( 10, insert_functor<Map>() ) );
 435             CPPUNIT_ASSERT( !m.insert_with( 25, insert_functor<Map>() ) );
 436             CPPUNIT_ASSERT( !m.insert_with( 30, insert_functor<Map>() ) );
 437
 438             // update() (new key)
 439             CPPUNIT_ASSERT( !m.contains(27) );
 440             updateResult = m.update(27, insert_functor<Map>(), false);
 441             CPPUNIT_ASSERT(!updateResult.first);
 442             CPPUNIT_ASSERT(!updateResult.second);
 443             CPPUNIT_ASSERT(!m.contains(27));
 444             updateResult = m.update( 27, insert_functor<Map>() ) ;   // value = 54
 445             CPPUNIT_ASSERT( updateResult.first );
 446             CPPUNIT_ASSERT( updateResult.second );
 447             CPPUNIT_ASSERT( m.contains(27) );
 448
 449             // find test
 450             check_value chk(10);
 451             CPPUNIT_ASSERT( m.find( 10, std::ref(chk) ));
 452             chk.m_nExpected = 0;
 453             CPPUNIT_ASSERT( m.find_with( 25, less(), std::ref( chk ) ) );
 454             chk.m_nExpected = 90;
 455             CPPUNIT_ASSERT( m.find( 30, std::ref( chk ) ) );
 456             chk.m_nExpected = 54;
 457             CPPUNIT_ASSERT( m.find( 27, std::ref( chk ) ) );
 458
 459             updateResult = m.update( 10, insert_functor<Map>(), false ) ;   // value = 50
 460             CPPUNIT_ASSERT( updateResult.first );
 461             CPPUNIT_ASSERT( !updateResult.second );
 462             chk.m_nExpected = 50;
 463             CPPUNIT_ASSERT( m.find( 10, std::ref( chk ) ) );
 464
 465             // erase test
 466             CPPUNIT_ASSERT( !m.contains(100) );
 467             CPPUNIT_ASSERT( !m.erase( 100 )) ;  // not found
 468
 469             CPPUNIT_ASSERT( m.contains(25) );
 470             CPPUNIT_ASSERT( check_size( m, 4 ));
 471             CPPUNIT_ASSERT( m.erase( 25 ));
 472             CPPUNIT_ASSERT( !m.empty() );
 473             CPPUNIT_ASSERT( check_size( m, 3 ));
 474             CPPUNIT_ASSERT( !m.contains(25) );
 475             CPPUNIT_ASSERT( !m.erase( 25 ));
 476
 477             CPPUNIT_ASSERT( !m.contains(258) );
 478             CPPUNIT_ASSERT( m.insert(258))
 479             CPPUNIT_ASSERT( check_size( m, 4 ));
 480             CPPUNIT_ASSERT( m.contains(258, less()) );
 481             CPPUNIT_ASSERT( m.erase_with( 258, less() ));
 482             CPPUNIT_ASSERT( !m.empty() );
 483             CPPUNIT_ASSERT( check_size( m, 3 ));
 484             CPPUNIT_ASSERT( !m.contains(258) );
 485             CPPUNIT_ASSERT( !m.erase_with( 258, less() ));
 486
 487             int nVal;
 488             extract_functor ext;
 489             ext.m_pVal = &nVal;
 490
 491             CPPUNIT_ASSERT( !m.contains(29) );
 492             CPPUNIT_ASSERT( m.insert(29, 290))
 493                 CPPUNIT_ASSERT( m.erase_with( 29, less(), std::ref( ext ) ) );
 494             CPPUNIT_ASSERT( !m.empty() );
 495             CPPUNIT_ASSERT( check_size( m, 3 ));
 496             CPPUNIT_ASSERT( nVal == 290 );
 497             nVal = -1;
 498             CPPUNIT_ASSERT( !m.erase_with( 29, less(), std::ref( ext ) ) );
 499             CPPUNIT_ASSERT( nVal == -1 );
 500
 501             CPPUNIT_ASSERT( m.erase( 30, std::ref( ext ) ) );
 502             CPPUNIT_ASSERT( !m.empty() );
 503             CPPUNIT_ASSERT( check_size( m, 2 ));
 504             CPPUNIT_ASSERT( nVal == 90 );
 505             nVal = -1;
 506             CPPUNIT_ASSERT( !m.erase( 30, std::ref( ext ) ) );
 507             CPPUNIT_ASSERT( nVal == -1 );
 508
 509             m.clear();
 510             CPPUNIT_ASSERT( m.empty() );
 511             CPPUNIT_ASSERT( check_size( m, 0 ));
 512
 513             // emplace test
 514             CPPUNIT_ASSERT( m.emplace(126) ) ; // key = 126, val = 0
 515             CPPUNIT_ASSERT( m.emplace(137, 731))    ;   // key = 137, val = 731
 516             CPPUNIT_ASSERT( m.emplace( 149, value_type(941) ))   ;   // key = 149, val = 941
 517
 518             CPPUNIT_ASSERT( !m.empty() );
 519             CPPUNIT_ASSERT( check_size( m, 3 ));
 520
 521             chk.m_nExpected = 0;
 522             CPPUNIT_ASSERT( m.find( 126, std::ref(chk) ));
 523             chk.m_nExpected = 731;
 524             CPPUNIT_ASSERT( m.find_with( 137, less(), std::ref(chk) ));
 525             chk.m_nExpected = 941;
 526             CPPUNIT_ASSERT( m.find( 149, std::ref(chk) ));
 527
 528             CPPUNIT_ASSERT( !m.emplace(126, 621)) ; // already in map
 529             chk.m_nExpected = 0;
 530             CPPUNIT_ASSERT( m.find( 126, std::ref(chk) ));
 531             CPPUNIT_ASSERT( !m.empty() );
 532             CPPUNIT_ASSERT( check_size( m, 3 ));
 533
 534             m.clear();
 535             CPPUNIT_ASSERT( m.empty() );
 536             CPPUNIT_ASSERT( check_size( m, 0 ));
 537         }
 538
 539         template <class Map>
 540         void test_striped_with2(Map& m)
 541         {
 542             cds::OS::Timer    timer;
 543
 544             test_int_with2( m );
 545
 546             // Iterators is not yet supported
 547             //m.clear();
 548             //CPPUNIT_ASSERT( m.empty() );
 549             //CPPUNIT_ASSERT( check_size( m, 0 ));
 550             //test_iter(m);
 551
 552             m.clear();
 553             CPPUNIT_ASSERT( m.empty() );
 554             CPPUNIT_ASSERT( check_size( m, 0 ));
 555
 556             // Resizing test
 557             for ( int i = 0; i < 40000; i++ ) {
 558                 m.insert( i );
 559             }
 560
 561             CPPUNIT_MSG( "   Duration=" << timer.duration() );
 562         }
 563
 564         template <class Map>
 565         void test_striped2()
 566         {
 567             Map m( 30 );
 568             CPPUNIT_ASSERT( m.bucket_count() == 32 );
 569             CPPUNIT_ASSERT( m.lock_count() == 32 );
 570
 571             test_striped_with2(m);
 572         }
 573
 574         void Striped_hashmap();
 575         void Striped_list();
 576         void Striped_map();
 577         void Striped_slist();
 578         void Striped_boost_list();
 579         void Striped_boost_flat_map();
 580         void Striped_boost_map();
 581         void Striped_boost_unordered_map();
 582
 583         void Refinable_hashmap();
 584         void Refinable_list();
 585         void Refinable_map();
 586         void Refinable_slist();
 587         void Refinable_boost_list();
 588         void Refinable_boost_flat_map();
 589         void Refinable_boost_map();
 590         void Refinable_boost_unordered_map();
 591
 592         CPPUNIT_TEST_SUITE(StripedMapHdrTest)
 593             CPPUNIT_TEST(Striped_hashmap)
 594             CPPUNIT_TEST(Striped_list)
 595             CPPUNIT_TEST(Striped_map)
 596             CPPUNIT_TEST(Striped_slist)
 597             CPPUNIT_TEST(Striped_boost_list)
 598             CPPUNIT_TEST(Striped_boost_flat_map)
 599             CPPUNIT_TEST(Striped_boost_map)
 600             CPPUNIT_TEST(Striped_boost_unordered_map)
 601
 602             CPPUNIT_TEST(Refinable_hashmap)
 603             CPPUNIT_TEST(Refinable_list)
 604             CPPUNIT_TEST(Refinable_map)
 605             CPPUNIT_TEST(Refinable_slist)
 606             CPPUNIT_TEST(Refinable_boost_list)
 607             CPPUNIT_TEST(Refinable_boost_flat_map)
 608             CPPUNIT_TEST(Refinable_boost_map)
 609             CPPUNIT_TEST(Refinable_boost_unordered_map)
 610         CPPUNIT_TEST_SUITE_END()
 611
 612     };
 613 }   // namespace map
 614
 615 #endif // #ifndef CDSTEST_HDR_STRIPED_MAP_H