tests/test-hdr/set/hdr_intrusive_striped_set.h

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