tests/test-hdr/set/hdr_intrusive_striped_set.h

   1 //$$CDS-header$$
   2
   3 #include "cppunit/cppunit_proxy.h"
   4 #include <cds/opt/hash.h>
   5
   6 // cds::intrusive namespace forward declaration
   7 namespace cds { namespace intrusive {}}
   8
   9 namespace set {
  10     namespace ci = cds::intrusive;
  11     namespace co = cds::opt;
  12
  13     // MichaelHashSet
  14     class IntrusiveStripedSetHdrTest: public CppUnitMini::TestCase
  15     {
  16     public:
  17         struct stat
  18         {
  19             unsigned int nDisposeCount  ;   // count of disposer calling
  20             unsigned int nFindCount     ;   // count of find-functor calling
  21             unsigned int nFindArgCount;
  22             unsigned int nInsertCount;
  23             unsigned int nEnsureNewCount;
  24             unsigned int nEnsureCount;
  25             unsigned int nEraseCount;
  26
  27             stat()
  28             {
  29                 memset( this, 0, sizeof(*this));
  30             }
  31
  32             stat& operator=( stat const& s)
  33             {
  34                 memcpy( this, &s, sizeof(*this));
  35                 return *this;
  36             }
  37         };
  38
  39         struct item
  40         {
  41             int nKey;
  42             int nVal;
  43
  44             item()
  45             {}
  46
  47             item(int key, int val)
  48                 : nKey( key )
  49                 , nVal(val)
  50             {}
  51
  52             item(const item& v )
  53                 : nKey( v.nKey )
  54                 , nVal( v.nVal )
  55             {}
  56
  57             int key() const
  58             {
  59                 return nKey;
  60             }
  61
  62             int val() const
  63             {
  64                 return nVal;
  65             }
  66         };
  67
  68         template <typename Hook>
  69         struct base_item
  70             : public item
  71             , public Hook
  72             , public stat
  73
  74         {
  75             base_item()
  76             {}
  77
  78             base_item(int key, int val)
  79                 : item( key, val )
  80             {}
  81
  82             base_item(const base_item& v )
  83                 : item( static_cast<item const&>(v) )
  84                 , stat()
  85             {}
  86         };
  87
  88         template <typename Hook>
  89         struct member_item
  90             : public item
  91             , public stat
  92         {
  93             Hook hMember;
  94
  95             member_item()
  96             {}
  97
  98             member_item(int key, int val)
  99                 : item( key, val )
 100             {}
 101
 102             member_item(const member_item& v )
 103                 : item( static_cast<item const&>(v))
 104                 , stat()
 105             {}
 106         };
 107
 108         struct find_key {
 109             int nKey;
 110
 111             find_key( int key )
 112                 : nKey(key)
 113             {}
 114         };
 115
 116         struct hash_int {
 117             size_t operator()( int i ) const
 118             {
 119                 return co::v::hash<int>()( i );
 120             }
 121             template <typename Item>
 122             size_t operator()( const Item& i ) const
 123             {
 124                 return (*this)( i.key() );
 125             }
 126             size_t operator()( find_key const& i) const
 127             {
 128                 return co::v::hash<int>()( i.nKey );
 129             }
 130         };
 131
 132         template <typename T>
 133         struct less
 134         {
 135             bool operator ()(const T& v1, const T& v2 ) const
 136             {
 137                 return v1.key() < v2.key();
 138             }
 139
 140             template <typename Q>
 141             bool operator ()(const T& v1, const Q& v2 ) const
 142             {
 143                 return v1.key() < v2;
 144             }
 145
 146             template <typename Q>
 147             bool operator ()(const Q& v1, const T& v2 ) const
 148             {
 149                 return v1 < v2.key();
 150             }
 151         };
 152
 153         template <typename T>
 154         struct cmp {
 155             int operator ()(const T& v1, const T& v2 ) const
 156             {
 157                 if ( v1.key() < v2.key() )
 158                     return -1;
 159                 return v1.key() > v2.key() ? 1 : 0;
 160             }
 161
 162             template <typename Q>
 163             int operator ()(const T& v1, const Q& v2 ) const
 164             {
 165                 if ( v1.key() < v2 )
 166                     return -1;
 167                 return v1.key() > v2 ? 1 : 0;
 168             }
 169
 170             template <typename Q>
 171             int operator ()(const Q& v1, const T& v2 ) const
 172             {
 173                 if ( v1 < v2.key() )
 174                     return -1;
 175                 return v1 > v2.key() ? 1 : 0;
 176             }
 177         };
 178
 179         struct faked_disposer
 180         {
 181             template <typename T>
 182             void operator ()( T * p )
 183             {
 184                 ++p->nDisposeCount;
 185             }
 186         };
 187
 188         struct insert_functor {
 189             template <typename Item>
 190             void operator()( Item& e)
 191             {
 192                 ++e.nInsertCount;
 193             }
 194         };
 195
 196         struct ensure_functor {
 197             template <typename Item>
 198             void operator()( bool bNew, Item& e, Item& arg )
 199             {
 200                 if ( bNew ) {
 201                     ++e.nEnsureNewCount;
 202                     CPPUNIT_ASSERT_CURRENT( &e == &arg );
 203                 }
 204                 else
 205                     ++e.nEnsureCount;
 206             }
 207         };
 208
 209         struct erase_functor {
 210             template< typename Item >
 211             void operator()( Item& e )
 212             {
 213                 ++e.nEraseCount;
 214             }
 215         };
 216
 217         struct find_functor {
 218             template <typename Item, typename What>
 219             void operator()( Item& e, What& )
 220             {
 221                 ++e.nFindCount;
 222             }
 223
 224             template <typename Item>
 225             void operator()( Item& e, Item& w )
 226             {
 227                 ++e.nFindCount;
 228                 ++w.nFindArgCount;
 229             }
 230         };
 231
 232         struct less2 {
 233             template <typename Item>
 234             bool operator()( Item const& e, find_key const& k ) const
 235             {
 236                 return e.key() < k.nKey;
 237             }
 238             template <typename Item>
 239             bool operator()( find_key const& k, Item const& e ) const
 240             {
 241                 return k.nKey < e.key();
 242             }
 243             template <typename Item>
 244             bool operator()( Item const& e, int k ) const
 245             {
 246                 return e.key() < k;
 247             }
 248             template <typename Item>
 249             bool operator()( int k, Item const& e ) const
 250             {
 251                 return k < e.key();
 252             }
 253         };
 254
 255         template <typename T>
 256         struct auto_dispose {
 257             T * m_pArr;
 258             auto_dispose( T * pArr ): m_pArr( pArr ) {}
 259             ~auto_dispose() { delete[] m_pArr; }
 260         };
 261
 262         template <class Set>
 263         void test_with(Set& s)
 264         {
 265             typedef typename Set::value_type    value_type;
 266
 267             int const k1 = 10;
 268             int const k2 = 25;
 269             int const k3 = 51;
 270
 271             int const v1 = 25;
 272             int const v2 = 56;
 273             int const v3 = 23;
 274
 275             value_type e1( k1, v1 );
 276             value_type e2( k2, v2 );
 277             value_type e3( k3, v3);
 278
 279             stat s1 = e1;
 280             stat s2 = e2;
 281             stat s3 = e3;
 282
 283             CPPUNIT_ASSERT( s.empty() );
 284             CPPUNIT_ASSERT( s.size() == 0 );
 285
 286             CPPUNIT_ASSERT( !s.find(k1));
 287             CPPUNIT_ASSERT( !s.find(k2));
 288             CPPUNIT_ASSERT( !s.find(k3));
 289
 290             CPPUNIT_ASSERT( s.insert(e1));
 291             CPPUNIT_ASSERT( s.find(e1));
 292             CPPUNIT_ASSERT( s.find(k1));
 293             CPPUNIT_ASSERT( !s.find(e2));
 294             CPPUNIT_ASSERT( !s.find(e3));
 295
 296             CPPUNIT_ASSERT( e2.nInsertCount == 0 );
 297             CPPUNIT_ASSERT( s.insert(e2, insert_functor() ));
 298             CPPUNIT_ASSERT( e2.nInsertCount == 1 );
 299             CPPUNIT_ASSERT( s.find(e1, find_functor() ));
 300             CPPUNIT_ASSERT( e1.nFindCount == 1 );
 301             CPPUNIT_ASSERT( e1.nFindArgCount == 1 );
 302             CPPUNIT_ASSERT( s.find(k1, find_functor() ));
 303             CPPUNIT_ASSERT( e1.nFindCount == 2 );
 304             CPPUNIT_ASSERT( e1.nFindArgCount == 1 );
 305             CPPUNIT_ASSERT( s.find(k2, find_functor() ));
 306             CPPUNIT_ASSERT( e2.nFindCount == 1 );
 307             CPPUNIT_ASSERT( e2.nFindArgCount == 0 );
 308             CPPUNIT_ASSERT( s.find(e2, find_functor() ));
 309             CPPUNIT_ASSERT( e2.nFindCount == 2 );
 310             CPPUNIT_ASSERT( e2.nFindArgCount == 1 );
 311             CPPUNIT_ASSERT( !s.find(k3, find_functor()));
 312             CPPUNIT_ASSERT( e3.nFindCount == 0 );
 313             CPPUNIT_ASSERT( e3.nFindArgCount == 0 );
 314             CPPUNIT_ASSERT( !s.find(e3, find_functor()));
 315             CPPUNIT_ASSERT( e3.nFindCount == 0 );
 316             CPPUNIT_ASSERT( e3.nFindArgCount == 0 );
 317
 318             s1 = e1 ; s2 = e2 ; s3 = e3;
 319
 320             CPPUNIT_ASSERT( e3.nEnsureNewCount == 0 );
 321             CPPUNIT_ASSERT( e3.nEnsureCount == 0 );
 322             CPPUNIT_ASSERT( s.ensure( e3, ensure_functor() ) == std::make_pair(true, true));
 323             CPPUNIT_ASSERT( e3.nEnsureNewCount == 1 );
 324             CPPUNIT_ASSERT( e3.nEnsureCount == 0 );
 325             CPPUNIT_ASSERT( s.find_with(find_key(k1), less2(), find_functor() ));
 326             CPPUNIT_ASSERT( e1.nFindCount == s1.nFindCount + 1 );
 327             CPPUNIT_ASSERT( e1.nFindArgCount == s1.nFindArgCount );
 328             CPPUNIT_ASSERT( s.find_with(k1, less2(), find_functor() ));
 329             CPPUNIT_ASSERT( e1.nFindCount == s1.nFindCount + 2 );
 330             CPPUNIT_ASSERT( e1.nFindArgCount == s1.nFindArgCount );
 331             CPPUNIT_ASSERT( s.find_with(k2, less2(), find_functor() ));
 332             CPPUNIT_ASSERT( e2.nFindCount == s2.nFindCount + 1 );
 333             CPPUNIT_ASSERT( e2.nFindArgCount == s2.nFindArgCount );
 334             CPPUNIT_ASSERT( s.find_with(find_key(k2), less2() ));
 335             CPPUNIT_ASSERT( e2.nFindCount == s2.nFindCount + 1 )        ;   // unchanged, no find_functor
 336             CPPUNIT_ASSERT( e2.nFindArgCount == s2.nFindArgCount );
 337             CPPUNIT_ASSERT( s.find_with(k3, less2() ));
 338             CPPUNIT_ASSERT( e3.nFindCount == s3.nFindCount )            ;   // unchanged, no find_functor
 339             CPPUNIT_ASSERT( e3.nFindArgCount == s3.nFindArgCount );
 340             CPPUNIT_ASSERT( s.find_with(find_key(k3), less2(), find_functor() ));
 341             CPPUNIT_ASSERT( e3.nFindCount == s3.nFindCount + 1 );
 342             CPPUNIT_ASSERT( e3.nFindArgCount == s3.nFindArgCount );
 343
 344             s1 = e1 ; s2 = e2 ; s3 = e3;
 345
 346             // insert existing elements
 347             {
 348                 value_type eu( k2, 1000 );
 349                 CPPUNIT_ASSERT( !s.insert( eu ));
 350                 CPPUNIT_ASSERT( !s.insert( eu, insert_functor() ));
 351                 CPPUNIT_ASSERT( e2.nInsertCount == s2.nInsertCount );
 352
 353                 CPPUNIT_ASSERT( s.ensure( eu, ensure_functor()) == std::make_pair(true, false));
 354                 CPPUNIT_ASSERT( e2.nInsertCount == s2.nInsertCount );
 355                 CPPUNIT_ASSERT( e2.nEnsureCount == s2.nEnsureCount + 1 );
 356                 CPPUNIT_ASSERT( e2.nEnsureNewCount == s2.nEnsureNewCount  );
 357             }
 358
 359             s1 = e1 ; s2 = e2 ; s3 = e3;
 360
 361             // unlink & erase test
 362             {
 363                 value_type eu( k2, 10 );
 364                 CPPUNIT_ASSERT( !s.unlink(eu));
 365             }
 366
 367             CPPUNIT_ASSERT( !s.empty() );
 368             CPPUNIT_ASSERT( s.size() == 3 );
 369
 370             CPPUNIT_ASSERT( s.unlink( e1 ) );
 371             CPPUNIT_ASSERT( s.erase_with( k2, less2() ) == &e2 );
 372             CPPUNIT_ASSERT( s.erase( e2 ) == nullptr );
 373             CPPUNIT_ASSERT( e3.nEraseCount == 0 );
 374             CPPUNIT_ASSERT( s.erase_with( k3, less2(), erase_functor()) == &e3 );
 375             CPPUNIT_ASSERT( e3.nEraseCount == 1 );
 376             CPPUNIT_ASSERT( s.erase( k3, erase_functor() ) == nullptr );
 377             CPPUNIT_ASSERT( e3.nEraseCount == 1 );
 378
 379             CPPUNIT_ASSERT( s.insert( e3 ) );
 380             CPPUNIT_ASSERT( s.erase( e3 ) == &e3 );
 381             CPPUNIT_ASSERT( e3.nEraseCount == 1 );
 382
 383             CPPUNIT_ASSERT( s.empty() );
 384             CPPUNIT_ASSERT( s.size() == 0 );
 385
 386             s1 = e1 ; s2 = e2 ; s3 = e3;
 387
 388             // clear & clear_and_dispose test
 389             CPPUNIT_ASSERT( s.insert(e1));
 390             CPPUNIT_ASSERT( s.insert(e2));
 391             CPPUNIT_ASSERT( s.insert(e3));
 392             CPPUNIT_ASSERT( !s.empty() );
 393             CPPUNIT_ASSERT( s.size() == 3 );
 394             s.clear();
 395             CPPUNIT_ASSERT( s.empty() );
 396             CPPUNIT_ASSERT( s.size() == 0 );
 397
 398             CPPUNIT_ASSERT( s.insert(e1));
 399             CPPUNIT_ASSERT( s.insert(e2));
 400             CPPUNIT_ASSERT( s.insert(e3));
 401             CPPUNIT_ASSERT( !s.empty() );
 402             CPPUNIT_ASSERT( s.size() == 3 );
 403
 404             CPPUNIT_ASSERT( e1.nDisposeCount == 0 );
 405             CPPUNIT_ASSERT( e2.nDisposeCount == 0 );
 406             CPPUNIT_ASSERT( e3.nDisposeCount == 0 );
 407             s.clear_and_dispose( faked_disposer() );
 408             CPPUNIT_ASSERT( e1.nDisposeCount == 1 );
 409             CPPUNIT_ASSERT( e2.nDisposeCount == 1 );
 410             CPPUNIT_ASSERT( e3.nDisposeCount == 1 );
 411             CPPUNIT_ASSERT( s.empty() );
 412             CPPUNIT_ASSERT( s.size() == 0 );
 413
 414             // resize test (up to 64K elements)
 415             size_t const nSize = 64 * 1024;
 416             value_type * arr = new value_type[nSize];
 417             auto_dispose<value_type> ad(arr);
 418             for ( size_t i = 0; i < nSize; ++i ) {
 419                 value_type * p = new (arr + i) value_type( (int) i, (int) i * 2 );
 420                 CPPUNIT_ASSERT_EX( s.insert( *p, insert_functor() ), "i=" << i );
 421                 CPPUNIT_ASSERT_EX( p->nInsertCount == 1, "i=" << i );
 422                 //for ( size_t j = 0; j <= i; ++j ) {
 423                 //    if ( !s.find((int) j) ) {
 424                 //        CPPUNIT_MSG( "Key " << j << " is not found after inserting key " << i );
 425                 //    }
 426                 //}
 427             }
 428
 429             for ( size_t i = 0; i < nSize; ++i )
 430                 CPPUNIT_ASSERT_EX( s.find((int) i), "Key " << i << " is not found" );
 431
 432             CPPUNIT_ASSERT( !s.empty() );
 433             CPPUNIT_ASSERT( s.size() == nSize );
 434             s.clear_and_dispose( faked_disposer() );
 435             for ( size_t i = 0; i < nSize; ++i ) {
 436                 CPPUNIT_ASSERT_EX( arr[i].nDisposeCount == 1, "i=" << i );
 437             }
 438         }
 439
 440         template <class Set>
 441         void test()
 442         {
 443             // default ctor
 444             {
 445                 Set s;
 446                 test_with(s);
 447             }
 448
 449             // ctor with explicit initial capacity
 450             {
 451                 Set s(256);
 452                 test_with(s);
 453             }
 454         }
 455
 456         template <class Set>
 457         void test_cuckoo()
 458         {
 459             unsigned int nProbesetSize = Set::node_type::probeset_size ? Set::node_type::probeset_size : 4;
 460             Set s( 256, nProbesetSize, nProbesetSize / 2 );
 461             test_with( s );
 462         }
 463
 464         // ***********************************************************
 465         // Striped set
 466
 467         void Striped_list_basehook_cmp();
 468         void Striped_list_basehook_less();
 469         void Striped_list_basehook_cmpmix();
 470         void Striped_list_basehook_bucket_threshold();
 471         void Striped_list_basehook_bucket_threshold_rt();
 472         void Striped_list_memberhook_cmp();
 473         void Striped_list_memberhook_less();
 474         void Striped_list_memberhook_cmpmix();
 475         void Striped_list_memberhook_bucket_threshold();
 476         void Striped_list_memberhook_bucket_threshold_rt();
 477
 478         void Striped_slist_basehook_cmp();
 479         void Striped_slist_basehook_less();
 480         void Striped_slist_basehook_cmpmix();
 481         void Striped_slist_basehook_bucket_threshold();
 482         void Striped_slist_basehook_bucket_threshold_rt();
 483         void Striped_slist_memberhook_cmp();
 484         void Striped_slist_memberhook_less();
 485         void Striped_slist_memberhook_cmpmix();
 486         void Striped_slist_memberhook_bucket_threshold();
 487         void Striped_slist_memberhook_bucket_threshold_rt();
 488
 489         void Striped_set_basehook();
 490         void Striped_set_basehook_bucket_threshold();
 491         void Striped_set_basehook_bucket_threshold_rt();
 492         void Striped_set_memberhook();
 493         void Striped_set_memberhook_bucket_threshold();
 494         void Striped_set_memberhook_bucket_threshold_rt();
 495
 496         void Striped_unordered_set_basehook();
 497         void Striped_unordered_set_basehook_bucket_threshold();
 498         void Striped_unordered_set_basehook_bucket_threshold_rt();
 499         void Striped_unordered_set_memberhook();
 500         void Striped_unordered_set_memberhook_bucket_threshold();
 501         void Striped_unordered_set_memberhook_bucket_threshold_rt();
 502
 503         void Striped_avl_set_basehook();
 504         void Striped_avl_set_basehook_bucket_threshold();
 505         void Striped_avl_set_basehook_bucket_threshold_rt();
 506         void Striped_avl_set_memberhook();
 507         void Striped_avl_set_memberhook_bucket_threshold();
 508         void Striped_avl_set_memberhook_bucket_threshold_rt();
 509
 510         void Striped_sg_set_basehook();
 511         void Striped_sg_set_basehook_bucket_threshold();
 512         void Striped_sg_set_basehook_bucket_threshold_rt();
 513         void Striped_sg_set_memberhook();
 514         void Striped_sg_set_memberhook_bucket_threshold();
 515         void Striped_sg_set_memberhook_bucket_threshold_rt();
 516
 517         void Striped_splay_set_basehook();
 518         void Striped_splay_set_basehook_bucket_threshold();
 519         void Striped_splay_set_basehook_bucket_threshold_rt();
 520         void Striped_splay_set_memberhook();
 521         void Striped_splay_set_memberhook_bucket_threshold();
 522         void Striped_splay_set_memberhook_bucket_threshold_rt();
 523
 524         void Striped_treap_set_basehook();
 525         void Striped_treap_set_basehook_bucket_threshold();
 526         void Striped_treap_set_basehook_bucket_threshold_rt();
 527         void Striped_treap_set_memberhook();
 528         void Striped_treap_set_memberhook_bucket_threshold();
 529         void Striped_treap_set_memberhook_bucket_threshold_rt();
 530
 531         // ***********************************************************
 532         // Refinable set
 533
 534         void Refinable_list_basehook_cmp();
 535         void Refinable_list_basehook_less();
 536         void Refinable_list_basehook_cmpmix();
 537         void Refinable_list_basehook_bucket_threshold();
 538         void Refinable_list_basehook_bucket_threshold_rt();
 539         void Refinable_list_memberhook_cmp();
 540         void Refinable_list_memberhook_less();
 541         void Refinable_list_memberhook_cmpmix();
 542         void Refinable_list_memberhook_bucket_threshold();
 543         void Refinable_list_memberhook_bucket_threshold_rt();
 544
 545         void Refinable_slist_basehook_cmp();
 546         void Refinable_slist_basehook_less();
 547         void Refinable_slist_basehook_cmpmix();
 548         void Refinable_slist_basehook_bucket_threshold();
 549         void Refinable_slist_basehook_bucket_threshold_rt();
 550         void Refinable_slist_memberhook_cmp();
 551         void Refinable_slist_memberhook_less();
 552         void Refinable_slist_memberhook_cmpmix();
 553         void Refinable_slist_memberhook_bucket_threshold();
 554         void Refinable_slist_memberhook_bucket_threshold_rt();
 555
 556         void Refinable_set_basehook();
 557         void Refinable_set_basehook_bucket_threshold();
 558         void Refinable_set_basehook_bucket_threshold_rt();
 559         void Refinable_set_memberhook();
 560         void Refinable_set_memberhook_bucket_threshold();
 561         void Refinable_set_memberhook_bucket_threshold_rt();
 562
 563         void Refinable_unordered_set_basehook();
 564         void Refinable_unordered_set_basehook_bucket_threshold();
 565         void Refinable_unordered_set_basehook_bucket_threshold_rt();
 566         void Refinable_unordered_set_memberhook();
 567         void Refinable_unordered_set_memberhook_bucket_threshold();
 568         void Refinable_unordered_set_memberhook_bucket_threshold_rt();
 569
 570         void Refinable_avl_set_basehook();
 571         void Refinable_avl_set_basehook_bucket_threshold();
 572         void Refinable_avl_set_basehook_bucket_threshold_rt();
 573         void Refinable_avl_set_memberhook();
 574         void Refinable_avl_set_memberhook_bucket_threshold();
 575         void Refinable_avl_set_memberhook_bucket_threshold_rt();
 576
 577         void Refinable_sg_set_basehook();
 578         void Refinable_sg_set_basehook_bucket_threshold();
 579         void Refinable_sg_set_basehook_bucket_threshold_rt();
 580         void Refinable_sg_set_memberhook();
 581         void Refinable_sg_set_memberhook_bucket_threshold();
 582         void Refinable_sg_set_memberhook_bucket_threshold_rt();
 583
 584         void Refinable_splay_set_basehook();
 585         void Refinable_splay_set_basehook_bucket_threshold();
 586         void Refinable_splay_set_basehook_bucket_threshold_rt();
 587         void Refinable_splay_set_memberhook();
 588         void Refinable_splay_set_memberhook_bucket_threshold();
 589         void Refinable_splay_set_memberhook_bucket_threshold_rt();
 590
 591         void Refinable_treap_set_basehook();
 592         void Refinable_treap_set_basehook_bucket_threshold();
 593         void Refinable_treap_set_basehook_bucket_threshold_rt();
 594         void Refinable_treap_set_memberhook();
 595         void Refinable_treap_set_memberhook_bucket_threshold();
 596         void Refinable_treap_set_memberhook_bucket_threshold_rt();
 597
 598         CPPUNIT_TEST_SUITE(IntrusiveStripedSetHdrTest)
 599             // ***********************************************************
 600             // Striped set
 601
 602             CPPUNIT_TEST( Striped_list_basehook_cmp)
 603             CPPUNIT_TEST( Striped_list_basehook_less)
 604             CPPUNIT_TEST( Striped_list_basehook_cmpmix)
 605             CPPUNIT_TEST( Striped_list_basehook_bucket_threshold)
 606             CPPUNIT_TEST( Striped_list_basehook_bucket_threshold_rt)
 607             CPPUNIT_TEST( Striped_list_memberhook_cmp)
 608             CPPUNIT_TEST( Striped_list_memberhook_less)
 609             CPPUNIT_TEST( Striped_list_memberhook_cmpmix)
 610             CPPUNIT_TEST( Striped_list_memberhook_bucket_threshold)
 611             CPPUNIT_TEST( Striped_list_memberhook_bucket_threshold_rt)
 612
 613             CPPUNIT_TEST( Striped_slist_basehook_cmp)
 614             CPPUNIT_TEST( Striped_slist_basehook_less)
 615             CPPUNIT_TEST( Striped_slist_basehook_cmpmix)
 616             CPPUNIT_TEST( Striped_slist_basehook_bucket_threshold)
 617             CPPUNIT_TEST( Striped_slist_basehook_bucket_threshold_rt)
 618             CPPUNIT_TEST( Striped_slist_memberhook_cmp)
 619             CPPUNIT_TEST( Striped_slist_memberhook_less)
 620             CPPUNIT_TEST( Striped_slist_memberhook_cmpmix)
 621             CPPUNIT_TEST( Striped_slist_memberhook_bucket_threshold)
 622             CPPUNIT_TEST( Striped_slist_memberhook_bucket_threshold_rt)
 623
 624             CPPUNIT_TEST( Striped_set_basehook )
 625             CPPUNIT_TEST( Striped_set_basehook_bucket_threshold )
 626             CPPUNIT_TEST( Striped_set_basehook_bucket_threshold_rt )
 627             CPPUNIT_TEST( Striped_set_memberhook)
 628             CPPUNIT_TEST( Striped_set_memberhook_bucket_threshold )
 629             CPPUNIT_TEST( Striped_set_memberhook_bucket_threshold_rt )
 630
 631             CPPUNIT_TEST( Striped_unordered_set_basehook )
 632             CPPUNIT_TEST( Striped_unordered_set_basehook_bucket_threshold )
 633             CPPUNIT_TEST( Striped_unordered_set_basehook_bucket_threshold_rt )
 634             CPPUNIT_TEST( Striped_unordered_set_memberhook)
 635             CPPUNIT_TEST( Striped_unordered_set_memberhook_bucket_threshold )
 636             CPPUNIT_TEST( Striped_unordered_set_memberhook_bucket_threshold_rt )
 637
 638             CPPUNIT_TEST( Striped_avl_set_basehook )
 639             CPPUNIT_TEST( Striped_avl_set_basehook_bucket_threshold )
 640             CPPUNIT_TEST( Striped_avl_set_basehook_bucket_threshold_rt )
 641             CPPUNIT_TEST( Striped_avl_set_memberhook)
 642             CPPUNIT_TEST( Striped_avl_set_memberhook_bucket_threshold )
 643             CPPUNIT_TEST( Striped_avl_set_memberhook_bucket_threshold_rt )
 644
 645             CPPUNIT_TEST( Striped_sg_set_basehook )
 646             CPPUNIT_TEST( Striped_sg_set_basehook_bucket_threshold )
 647             CPPUNIT_TEST( Striped_sg_set_basehook_bucket_threshold_rt )
 648             CPPUNIT_TEST( Striped_sg_set_memberhook)
 649             CPPUNIT_TEST( Striped_sg_set_memberhook_bucket_threshold )
 650             CPPUNIT_TEST( Striped_sg_set_memberhook_bucket_threshold_rt )
 651
 652             CPPUNIT_TEST( Striped_splay_set_basehook )
 653             CPPUNIT_TEST( Striped_splay_set_basehook_bucket_threshold )
 654             CPPUNIT_TEST( Striped_splay_set_basehook_bucket_threshold_rt )
 655             CPPUNIT_TEST( Striped_splay_set_memberhook)
 656             CPPUNIT_TEST( Striped_splay_set_memberhook_bucket_threshold )
 657             CPPUNIT_TEST( Striped_splay_set_memberhook_bucket_threshold_rt )
 658
 659             CPPUNIT_TEST( Striped_treap_set_basehook )
 660             CPPUNIT_TEST( Striped_treap_set_basehook_bucket_threshold )
 661             CPPUNIT_TEST( Striped_treap_set_basehook_bucket_threshold_rt )
 662             CPPUNIT_TEST( Striped_treap_set_memberhook)
 663             CPPUNIT_TEST( Striped_treap_set_memberhook_bucket_threshold )
 664             CPPUNIT_TEST( Striped_treap_set_memberhook_bucket_threshold_rt )
 665
 666             // ***********************************************************
 667             // Refinable set
 668
 669             CPPUNIT_TEST( Refinable_list_basehook_cmp)
 670             CPPUNIT_TEST( Refinable_list_basehook_less)
 671             CPPUNIT_TEST( Refinable_list_basehook_cmpmix)
 672             CPPUNIT_TEST( Refinable_list_basehook_bucket_threshold)
 673             CPPUNIT_TEST( Refinable_list_basehook_bucket_threshold_rt)
 674             CPPUNIT_TEST( Refinable_list_memberhook_cmp)
 675             CPPUNIT_TEST( Refinable_list_memberhook_less)
 676             CPPUNIT_TEST( Refinable_list_memberhook_cmpmix)
 677             CPPUNIT_TEST( Refinable_list_memberhook_bucket_threshold)
 678             CPPUNIT_TEST( Refinable_list_memberhook_bucket_threshold_rt)
 679
 680             CPPUNIT_TEST( Refinable_slist_basehook_cmp)
 681             CPPUNIT_TEST( Refinable_slist_basehook_less)
 682             CPPUNIT_TEST( Refinable_slist_basehook_cmpmix)
 683             CPPUNIT_TEST( Refinable_slist_basehook_bucket_threshold)
 684             CPPUNIT_TEST( Refinable_slist_basehook_bucket_threshold_rt)
 685             CPPUNIT_TEST( Refinable_slist_memberhook_cmp)
 686             CPPUNIT_TEST( Refinable_slist_memberhook_less)
 687             CPPUNIT_TEST( Refinable_slist_memberhook_cmpmix)
 688             CPPUNIT_TEST( Refinable_slist_memberhook_bucket_threshold)
 689             CPPUNIT_TEST( Refinable_slist_memberhook_bucket_threshold_rt)
 690
 691             CPPUNIT_TEST( Refinable_set_basehook )
 692             CPPUNIT_TEST( Refinable_set_basehook_bucket_threshold )
 693             CPPUNIT_TEST( Refinable_set_basehook_bucket_threshold_rt )
 694             CPPUNIT_TEST( Refinable_set_memberhook)
 695             CPPUNIT_TEST( Refinable_set_memberhook_bucket_threshold )
 696             CPPUNIT_TEST( Refinable_set_memberhook_bucket_threshold_rt )
 697
 698             CPPUNIT_TEST( Refinable_unordered_set_basehook )
 699             CPPUNIT_TEST( Refinable_unordered_set_basehook_bucket_threshold )
 700             CPPUNIT_TEST( Refinable_unordered_set_basehook_bucket_threshold_rt )
 701             CPPUNIT_TEST( Refinable_unordered_set_memberhook)
 702             CPPUNIT_TEST( Refinable_unordered_set_memberhook_bucket_threshold )
 703             CPPUNIT_TEST( Refinable_unordered_set_memberhook_bucket_threshold_rt )
 704
 705             CPPUNIT_TEST( Refinable_avl_set_basehook )
 706             CPPUNIT_TEST( Refinable_avl_set_basehook_bucket_threshold )
 707             CPPUNIT_TEST( Refinable_avl_set_basehook_bucket_threshold_rt )
 708             CPPUNIT_TEST( Refinable_avl_set_memberhook)
 709             CPPUNIT_TEST( Refinable_avl_set_memberhook_bucket_threshold )
 710             CPPUNIT_TEST( Refinable_avl_set_memberhook_bucket_threshold_rt )
 711
 712             CPPUNIT_TEST( Refinable_sg_set_basehook )
 713             CPPUNIT_TEST( Refinable_sg_set_basehook_bucket_threshold )
 714             CPPUNIT_TEST( Refinable_sg_set_basehook_bucket_threshold_rt )
 715             CPPUNIT_TEST( Refinable_sg_set_memberhook)
 716             CPPUNIT_TEST( Refinable_sg_set_memberhook_bucket_threshold )
 717             CPPUNIT_TEST( Refinable_sg_set_memberhook_bucket_threshold_rt )
 718
 719             CPPUNIT_TEST( Refinable_splay_set_basehook )
 720             CPPUNIT_TEST( Refinable_splay_set_basehook_bucket_threshold )
 721             CPPUNIT_TEST( Refinable_splay_set_basehook_bucket_threshold_rt )
 722             CPPUNIT_TEST( Refinable_splay_set_memberhook)
 723             CPPUNIT_TEST( Refinable_splay_set_memberhook_bucket_threshold )
 724             CPPUNIT_TEST( Refinable_splay_set_memberhook_bucket_threshold_rt )
 725
 726             CPPUNIT_TEST( Refinable_treap_set_basehook )
 727             CPPUNIT_TEST( Refinable_treap_set_basehook_bucket_threshold )
 728             CPPUNIT_TEST( Refinable_treap_set_basehook_bucket_threshold_rt )
 729             CPPUNIT_TEST( Refinable_treap_set_memberhook)
 730             CPPUNIT_TEST( Refinable_treap_set_memberhook_bucket_threshold )
 731             CPPUNIT_TEST( Refinable_treap_set_memberhook_bucket_threshold_rt )
 732         CPPUNIT_TEST_SUITE_END()
 733     };
 734 } // namespace set