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     // MichaelHashSet
  17     class IntrusiveStripedSetHdrTest: public CppUnitMini::TestCase
  18     {
  19     public:
  20         struct stat
  21         {
  22             unsigned int nDisposeCount  ;   // count of disposer calling
  23             unsigned int nFindCount     ;   // count of find-functor calling
  24             unsigned int nFindArgCount;
  25             unsigned int nInsertCount;
  26             unsigned int nUpdateNewCount;
  27             unsigned int nUpdateCount;
  28             unsigned int nEraseCount;
  29
  30             stat()
  31             {
  32                 memset( this, 0, sizeof(*this));
  33             }
  34
  35             stat& operator=( stat const& s)
  36             {
  37                 memcpy( this, &s, sizeof(*this));
  38                 return *this;
  39             }
  40         };
  41
  42         struct item
  43         {
  44             int nKey;
  45             int nVal;
  46
  47             item()
  48             {}
  49
  50             explicit item( int key )
  51                 : nKey( key )
  52                 , nVal(0)
  53             {}
  54
  55             item(int key, int val)
  56                 : nKey( key )
  57                 , nVal(val)
  58             {}
  59
  60             item(const item& v )
  61                 : nKey( v.nKey )
  62                 , nVal( v.nVal )
  63             {}
  64
  65             int key() const
  66             {
  67                 return nKey;
  68             }
  69
  70             int val() const
  71             {
  72                 return nVal;
  73             }
  74         };
  75
  76         template <typename Hook>
  77         struct base_item
  78             : public item
  79             , public Hook
  80             , public stat
  81
  82         {
  83             base_item()
  84             {}
  85
  86             explicit base_item( int key )
  87                 : item( key )
  88             {}
  89
  90             base_item(int key, int val)
  91                 : item( key, val )
  92             {}
  93
  94             base_item(const base_item& v )
  95                 : item( static_cast<item const&>(v) )
  96                 , stat()
  97             {}
  98
  99             operator int() const
 100             {
 101                 return key();
 102             }
 103         };
 104
 105         template <typename Hook>
 106         struct member_item
 107             : public item
 108             , public stat
 109         {
 110             Hook hMember;
 111
 112             member_item()
 113             {}
 114
 115             explicit member_item( int key )
 116                 : item( key )
 117             {}
 118
 119             member_item(int key, int val)
 120                 : item( key, val )
 121             {}
 122
 123             member_item(const member_item& v )
 124                 : item( static_cast<item const&>(v))
 125                 , stat()
 126             {}
 127
 128             operator int() const
 129             {
 130                 return key();
 131             }
 132         };
 133
 134         struct find_key {
 135             int nKey;
 136
 137             find_key( int key )
 138                 : nKey(key)
 139             {}
 140         };
 141
 142         struct hash_int {
 143             size_t operator()( int i ) const
 144             {
 145                 return co::v::hash<int>()( i );
 146             }
 147             template <typename Item>
 148             size_t operator()( const Item& i ) const
 149             {
 150                 return (*this)( i.key() );
 151             }
 152             size_t operator()( find_key const& i) const
 153             {
 154                 return co::v::hash<int>()( i.nKey );
 155             }
 156         };
 157
 158         template <typename T>
 159         struct less
 160         {
 161             bool operator ()(const T& v1, const T& v2 ) const
 162             {
 163                 return v1.key() < v2.key();
 164             }
 165
 166             template <typename Q>
 167             bool operator ()(const T& v1, const Q& v2 ) const
 168             {
 169                 return v1.key() < v2;
 170             }
 171
 172             template <typename Q>
 173             bool operator ()(const Q& v1, const T& v2 ) const
 174             {
 175                 return v1 < v2.key();
 176             }
 177
 178             bool operator()( int i1, int i2 ) const
 179             {
 180                 return i1 < i2;
 181             }
 182         };
 183
 184         template <typename T>
 185         struct cmp {
 186             int operator ()(const T& v1, const T& v2 ) const
 187             {
 188                 if ( v1.key() < v2.key() )
 189                     return -1;
 190                 return v1.key() > v2.key() ? 1 : 0;
 191             }
 192
 193             template <typename Q>
 194             int operator ()(const T& v1, const Q& v2 ) const
 195             {
 196                 if ( v1.key() < v2 )
 197                     return -1;
 198                 return v1.key() > v2 ? 1 : 0;
 199             }
 200
 201             template <typename Q>
 202             int operator ()(const Q& v1, const T& v2 ) const
 203             {
 204                 if ( v1 < v2.key() )
 205                     return -1;
 206                 return v1 > v2.key() ? 1 : 0;
 207             }
 208         };
 209
 210         struct faked_disposer
 211         {
 212             template <typename T>
 213             void operator ()( T * p )
 214             {
 215                 ++p->nDisposeCount;
 216             }
 217         };
 218
 219         struct insert_functor {
 220             template <typename Item>
 221             void operator()( Item& e)
 222             {
 223                 ++e.nInsertCount;
 224             }
 225         };
 226
 227         struct update_functor {
 228             template <typename Item>
 229             void operator()( bool bNew, Item& e, Item& arg )
 230             {
 231                 if ( bNew ) {
 232                     ++e.nUpdateNewCount;
 233                     CPPUNIT_ASSERT_CURRENT( &e == &arg );
 234                 }
 235                 else
 236                     ++e.nUpdateCount;
 237             }
 238         };
 239
 240         struct erase_functor {
 241             template< typename Item >
 242             void operator()( Item& e )
 243             {
 244                 ++e.nEraseCount;
 245             }
 246         };
 247
 248         struct find_functor {
 249             template <typename Item, typename What>
 250             void operator()( Item& e, What& )
 251             {
 252                 ++e.nFindCount;
 253             }
 254
 255             template <typename Item>
 256             void operator()( Item& e, Item& w )
 257             {
 258                 ++e.nFindCount;
 259                 ++w.nFindArgCount;
 260             }
 261         };
 262
 263         template <typename T>
 264         struct get_int_key
 265         {
 266             int operator()( T const & v ) const
 267             {
 268                 return v.key();
 269             }
 270         };
 271
 272         template <>
 273         struct get_int_key<int>
 274         {
 275             int operator()( int i ) const
 276             {
 277                 return i;
 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