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