tests/test-hdr/set/hdr_intrusive_set.h

   1 //$$CDS-header$$
   2
   3 #include "cppunit/cppunit_proxy.h"
   4 #include "size_check.h"
   5
   6 #include <cds/opt/hash.h>
   7 #include <functional>   // ref
   8 #include <algorithm>    // random_shuffle
   9
  10 // forward declaration
  11 namespace cds { namespace intrusive {} }
  12
  13 namespace set {
  14     using misc::check_size;
  15
  16     namespace ci = cds::intrusive;
  17     namespace co = cds::opt;
  18
  19     class IntrusiveHashSetHdrTest: public CppUnitMini::TestCase
  20     {
  21     protected:
  22         struct stat
  23         {
  24             unsigned int nDisposeCount  ;   // count of disposer calling
  25             unsigned int nFindCount     ;   // count of find-functor calling
  26             unsigned int nEnsureNewCount;
  27             unsigned int nEnsureCount;
  28             mutable unsigned int nEraseCount;
  29
  30             stat()
  31             {
  32                 memset( this, 0, sizeof(*this));
  33             }
  34         };
  35
  36         template <typename Node>
  37         struct base_int_item
  38             : public Node
  39             , public stat
  40
  41         {
  42             int nKey;
  43             int nVal;
  44
  45             base_int_item()
  46             {}
  47
  48             base_int_item(int key, int val)
  49                 : nKey( key )
  50                 , nVal(val)
  51             {}
  52
  53             base_int_item(const base_int_item& v )
  54                 : stat()
  55                 , nKey( v.nKey )
  56                 , nVal( v.nVal )
  57             {}
  58
  59             int key() const
  60             {
  61                 return nKey;
  62             }
  63         };
  64
  65         template <typename Node>
  66         struct member_int_item: public stat
  67         {
  68             int nKey;
  69             int nVal;
  70
  71             Node hMember;
  72
  73             stat s;
  74
  75             member_int_item()
  76             {}
  77
  78             member_int_item(int key, int val)
  79                 : nKey( key )
  80                 , nVal(val)
  81             {}
  82
  83             member_int_item(const member_int_item& v )
  84                 : stat()
  85                 , nKey( v.nKey )
  86                 , nVal( v.nVal )
  87             {}
  88
  89             int key() const
  90             {
  91                 return nKey;
  92             }
  93         };
  94
  95         struct hash_int {
  96             size_t operator()( int i ) const
  97             {
  98                 return co::v::hash<int>()( i );
  99             }
 100             template <typename Item>
 101             size_t operator()( const Item& i ) const
 102             {
 103                 return (*this)( i.key() );
 104             }
 105         };
 106
 107         struct simple_item_counter {
 108             size_t  m_nCount;
 109
 110             simple_item_counter()
 111                 : m_nCount(0)
 112             {}
 113
 114             size_t operator ++()
 115             {
 116                 return ++m_nCount;
 117             }
 118
 119             size_t operator --()
 120             {
 121                 return --m_nCount;
 122             }
 123
 124             void reset()
 125             {
 126                 m_nCount = 0;
 127             }
 128
 129             operator size_t() const
 130             {
 131                 return m_nCount;
 132             }
 133
 134         };
 135
 136
 137         template <typename T>
 138         struct less
 139         {
 140             bool operator ()(const T& v1, const T& v2 ) const
 141             {
 142                 return v1.key() < v2.key();
 143             }
 144
 145             template <typename Q>
 146             bool operator ()(const T& v1, const Q& v2 ) const
 147             {
 148                 return v1.key() < v2;
 149             }
 150
 151             template <typename Q>
 152             bool operator ()(const Q& v1, const T& v2 ) const
 153             {
 154                 return v1 < v2.key();
 155             }
 156         };
 157
 158         template <typename T>
 159         struct cmp {
 160             int operator ()(const T& v1, const T& v2 ) const
 161             {
 162                 if ( v1.key() < v2.key() )
 163                     return -1;
 164                 return v1.key() > v2.key() ? 1 : 0;
 165             }
 166
 167             template <typename Q>
 168             int operator ()(const T& v1, const Q& v2 ) const
 169             {
 170                 if ( v1.key() < v2 )
 171                     return -1;
 172                 return v1.key() > v2 ? 1 : 0;
 173             }
 174
 175             template <typename Q>
 176             int operator ()(const Q& v1, const T& v2 ) const
 177             {
 178                 if ( v1 < v2.key() )
 179                     return -1;
 180                 return v1 > v2.key() ? 1 : 0;
 181             }
 182         };
 183
 184         struct faked_disposer
 185         {
 186             template <typename T>
 187             void operator ()( T * p )
 188             {
 189                 ++p->nDisposeCount;
 190             }
 191         };
 192
 193         struct find_functor
 194         {
 195             template <typename Item, typename T>
 196             void operator()( Item& item, T& val )
 197             {
 198                 ++item.nFindCount;
 199             }
 200         };
 201
 202         struct insert_functor
 203         {
 204             template <typename Item>
 205             void operator()(Item& item )
 206             {
 207                 item.nVal = item.nKey * 100;
 208             }
 209         };
 210
 211         struct ensure_functor
 212         {
 213             template <typename Item>
 214             void operator()( bool bNew, Item& item, Item& val )
 215             {
 216                 if ( bNew )
 217                     ++item.nEnsureNewCount;
 218                 else
 219                     ++item.nEnsureCount;
 220             }
 221         };
 222
 223         struct erase_functor
 224         {
 225             template <typename Item>
 226             void operator()( Item const& item )
 227             {
 228                 item.nEraseCount++;
 229             }
 230         };
 231
 232         template <class Set>
 233         void test_int_with( Set& s )
 234         {
 235             typedef typename Set::value_type    value_type;
 236
 237             value_type v1( 10, 50 );
 238             value_type v2( 5, 25  );
 239             value_type v3( 20, 100 );
 240             int key;
 241
 242             CPPUNIT_ASSERT( s.empty() );
 243             CPPUNIT_ASSERT( check_size( s, 0 ));
 244
 245             // insert/find test
 246             CPPUNIT_ASSERT( !s.find( v1.key() ));
 247             CPPUNIT_ASSERT( s.insert( v1 ));
 248             CPPUNIT_ASSERT( s.find( v1.key() ));
 249             CPPUNIT_ASSERT( check_size( s, 1 ));
 250             CPPUNIT_ASSERT( !s.empty() );
 251
 252             CPPUNIT_ASSERT( !s.find_with( v2.key(), less<value_type>() ));
 253             CPPUNIT_ASSERT( s.insert( v2 ));
 254             CPPUNIT_ASSERT( v2.nFindCount == 0 );
 255             CPPUNIT_ASSERT( s.find_with( key = v2.key(), less<value_type>(), find_functor() ));
 256             CPPUNIT_ASSERT( v2.nFindCount == 1 );
 257             v2.nFindCount = 0;
 258             CPPUNIT_ASSERT( check_size( s, 2 ));
 259             CPPUNIT_ASSERT( !s.empty() );
 260
 261             {
 262                 insert_functor  fi;
 263                 find_functor    ff;
 264                 CPPUNIT_ASSERT( !s.find( v3 ));
 265                 CPPUNIT_ASSERT( v3.nVal != v3.nKey * 100 );
 266                 CPPUNIT_ASSERT( s.insert( v3, std::ref(fi) ));
 267                 CPPUNIT_ASSERT( v3.nVal == v3.nKey * 100 );
 268                 CPPUNIT_ASSERT( v3.nFindCount == 0 );
 269                 CPPUNIT_ASSERT( s.find( v3, std::ref(ff) ));
 270                 CPPUNIT_ASSERT( v3.nFindCount == 1 );
 271                 v3.nFindCount = 0;
 272                 CPPUNIT_ASSERT( check_size( s, 3 ));
 273                 CPPUNIT_ASSERT( !s.empty() );
 274             }
 275
 276             // unlink test
 277             CPPUNIT_ASSERT( s.unlink( v1 ));
 278             CPPUNIT_ASSERT( !s.find( v1 ));
 279             CPPUNIT_ASSERT( s.find( v2 ));
 280             CPPUNIT_ASSERT( s.find( v3 ));
 281             CPPUNIT_ASSERT( check_size( s, 2 ));
 282
 283             CPPUNIT_ASSERT( !s.unlink( v1 ));
 284             CPPUNIT_ASSERT( !s.find( v1 ));
 285             CPPUNIT_ASSERT( check_size( s, 2 ));
 286
 287             CPPUNIT_ASSERT( s.find_with( v3, less<value_type>() ));
 288             CPPUNIT_ASSERT( s.unlink( v3 ));
 289             CPPUNIT_ASSERT( !s.find_with( v3, less<value_type>() ));
 290             CPPUNIT_ASSERT( check_size( s, 1 ));
 291
 292             CPPUNIT_ASSERT( s.find( v2 ));
 293             CPPUNIT_ASSERT( s.unlink( v2 ));
 294             CPPUNIT_ASSERT( !s.find( v1 ));
 295             CPPUNIT_ASSERT( !s.find( v2 ));
 296             CPPUNIT_ASSERT( !s.find( v3 ));
 297             CPPUNIT_ASSERT( check_size( s, 0 ));
 298             CPPUNIT_ASSERT( s.empty() );
 299
 300             Set::gc::force_dispose();
 301             // unlink function calls disposer
 302             CPPUNIT_ASSERT( v1.nDisposeCount == 1 );
 303             CPPUNIT_ASSERT( v2.nDisposeCount == 1 );
 304             CPPUNIT_ASSERT( v3.nDisposeCount == 1 );
 305
 306             // ensure test
 307             {
 308                 ensure_functor f;
 309                 std::pair<bool, bool> ret = s.ensure( v1, f );
 310                 CPPUNIT_ASSERT( ret.first );
 311                 CPPUNIT_ASSERT( ret.second );
 312                 CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 313                 CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
 314                 CPPUNIT_ASSERT( check_size( s, 1 ));
 315
 316                 ret = s.ensure( v2, f );
 317                 CPPUNIT_ASSERT( ret.first );
 318                 CPPUNIT_ASSERT( ret.second );
 319                 CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 320                 CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
 321                 CPPUNIT_ASSERT( check_size( s, 2 ));
 322
 323                 ret = s.ensure( v3, f );
 324                 CPPUNIT_ASSERT( ret.first );
 325                 CPPUNIT_ASSERT( ret.second );
 326                 CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 327                 CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
 328                 CPPUNIT_ASSERT( check_size( s, 3 ));
 329
 330                 CPPUNIT_ASSERT( s.find( v1 ));
 331                 CPPUNIT_ASSERT( s.find( v2 ));
 332                 CPPUNIT_ASSERT( s.find( v3 ));
 333
 334                 ret = s.ensure( v1, f );
 335                 CPPUNIT_ASSERT( ret.first );
 336                 CPPUNIT_ASSERT( !ret.second );
 337                 CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 338                 CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
 339                 CPPUNIT_ASSERT( check_size( s, 3 ));
 340
 341                 ret = s.ensure( v2, f );
 342                 CPPUNIT_ASSERT( ret.first );
 343                 CPPUNIT_ASSERT( !ret.second );
 344                 CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 345                 CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
 346                 CPPUNIT_ASSERT( check_size( s, 3 ));
 347
 348                 ret = s.ensure( v3, f );
 349                 CPPUNIT_ASSERT( ret.first );
 350                 CPPUNIT_ASSERT( !ret.second );
 351                 CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 352                 CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
 353                 CPPUNIT_ASSERT( check_size( s, 3 ));
 354
 355                 CPPUNIT_ASSERT( s.find( v1 ));
 356                 CPPUNIT_ASSERT( s.find( v2 ));
 357                 CPPUNIT_ASSERT( s.find( v3 ));
 358             }
 359
 360             // erase test
 361             CPPUNIT_ASSERT( s.find( v1 ));
 362             CPPUNIT_ASSERT( s.find_with( v2, less<value_type>() ));
 363             CPPUNIT_ASSERT( s.find( v3 ));
 364             CPPUNIT_ASSERT( check_size( s, 3 ));
 365             CPPUNIT_ASSERT( !s.empty() );
 366
 367             CPPUNIT_ASSERT( s.erase( v1 ));
 368             CPPUNIT_ASSERT( !s.find( v1 ));
 369             CPPUNIT_ASSERT( s.find( v2 ));
 370             CPPUNIT_ASSERT( s.find( v3 ));
 371             CPPUNIT_ASSERT( check_size( s, 2 ));
 372             CPPUNIT_ASSERT( !s.empty() );
 373
 374             CPPUNIT_ASSERT( v1.nEraseCount == 0 );
 375             CPPUNIT_ASSERT( !s.erase( v1, erase_functor() ));
 376             CPPUNIT_ASSERT( v1.nEraseCount == 0 );
 377             CPPUNIT_ASSERT( !s.find( v1 ));
 378             CPPUNIT_ASSERT( s.find( v2 ));
 379             CPPUNIT_ASSERT( s.find( v3 ));
 380             CPPUNIT_ASSERT( check_size( s, 2 ));
 381             CPPUNIT_ASSERT( !s.empty() );
 382
 383             CPPUNIT_ASSERT( v2.nEraseCount == 0 );
 384             CPPUNIT_ASSERT( s.erase_with( v2.key(), less<value_type>(), erase_functor() ));
 385             CPPUNIT_ASSERT( v2.nEraseCount == 1 );
 386             CPPUNIT_ASSERT( !s.find( v1 ));
 387             CPPUNIT_ASSERT( !s.find( v2 ));
 388             CPPUNIT_ASSERT( s.find( v3 ));
 389             CPPUNIT_ASSERT( check_size( s, 1 ));
 390             CPPUNIT_ASSERT( !s.empty() );
 391
 392             CPPUNIT_ASSERT( !s.erase( v2.key() ));
 393             CPPUNIT_ASSERT( !s.find( v1 ));
 394             CPPUNIT_ASSERT( !s.find( v2 ));
 395             CPPUNIT_ASSERT( s.find( v3 ));
 396             CPPUNIT_ASSERT( check_size( s, 1 ));
 397             CPPUNIT_ASSERT( !s.empty() );
 398
 399             CPPUNIT_ASSERT( s.erase( v3 ));
 400             CPPUNIT_ASSERT( !s.find( v1 ));
 401             CPPUNIT_ASSERT( !s.find( v2 ));
 402             CPPUNIT_ASSERT( !s.find( v3 ));
 403             CPPUNIT_ASSERT( check_size( s, 0 ));
 404             CPPUNIT_ASSERT( s.empty() );
 405
 406             // dispose test
 407             Set::gc::force_dispose();
 408             CPPUNIT_ASSERT( v1.nDisposeCount == 2 );
 409             CPPUNIT_ASSERT( v2.nDisposeCount == 2 );
 410             CPPUNIT_ASSERT( v3.nDisposeCount == 2 );
 411
 412             CPPUNIT_ASSERT( s.empty() );
 413             CPPUNIT_ASSERT( s.insert( v1 ));
 414             CPPUNIT_ASSERT( s.insert( v3 ));
 415             CPPUNIT_ASSERT( check_size( s, 2 ));
 416             CPPUNIT_ASSERT( !s.empty() );
 417
 418             {
 419                 value_type v( v1 );
 420                 CPPUNIT_ASSERT( !s.unlink( v ) );
 421             }
 422
 423             CPPUNIT_ASSERT( s.unlink( v3 ) );
 424             CPPUNIT_ASSERT( s.find( v1 ));
 425             CPPUNIT_ASSERT( !s.find( v2 ));
 426             CPPUNIT_ASSERT( !s.find( v3 ));
 427             CPPUNIT_ASSERT( check_size( s, 1 ));
 428             CPPUNIT_ASSERT( !s.empty() );
 429
 430             CPPUNIT_ASSERT( !s.unlink( v3 ));
 431             CPPUNIT_ASSERT( s.find( v1 ));
 432             CPPUNIT_ASSERT( !s.find( v2 ));
 433             CPPUNIT_ASSERT( !s.find( v3 ));
 434             CPPUNIT_ASSERT( check_size( s, 1 ));
 435             CPPUNIT_ASSERT( !s.empty() );
 436
 437             CPPUNIT_ASSERT( s.unlink( v1 ));
 438             CPPUNIT_ASSERT( !s.find( v1 ));
 439             CPPUNIT_ASSERT( !s.find( v2 ));
 440             CPPUNIT_ASSERT( !s.find( v3 ));
 441             CPPUNIT_ASSERT( check_size( s, 0 ));
 442             CPPUNIT_ASSERT( s.empty() );
 443
 444             CPPUNIT_ASSERT( !s.unlink( v2 ));
 445             CPPUNIT_ASSERT( !s.find( v1 ));
 446             CPPUNIT_ASSERT( !s.find( v2 ));
 447             CPPUNIT_ASSERT( !s.find( v3 ));
 448             CPPUNIT_ASSERT( check_size( s, 0 ));
 449             CPPUNIT_ASSERT( s.empty() );
 450
 451             Set::gc::force_dispose();
 452             CPPUNIT_ASSERT( v1.nDisposeCount == 3 );
 453             CPPUNIT_ASSERT( v2.nDisposeCount == 2 );
 454             CPPUNIT_ASSERT( v3.nDisposeCount == 3 );
 455
 456             // clear test
 457             CPPUNIT_ASSERT( s.insert( v1 ));
 458             CPPUNIT_ASSERT( s.insert( v3 ));
 459             CPPUNIT_ASSERT( s.insert( v2 ));
 460
 461             s.clear();
 462             CPPUNIT_ASSERT( s.empty() );
 463             CPPUNIT_ASSERT( check_size( s, 0 ));
 464             Set::gc::force_dispose();
 465             CPPUNIT_CHECK( v1.nDisposeCount == 4 );
 466             CPPUNIT_CHECK( v2.nDisposeCount == 3 );
 467             CPPUNIT_CHECK( v3.nDisposeCount == 4 );
 468         }
 469
 470
 471         template <class Set>
 472         void test_int()
 473         {
 474             {
 475                 Set s( 64, 4 );
 476                 test_int_with( s );
 477             }
 478
 479             // Iterator test
 480             test_iter<Set>();
 481
 482             // extract/get test
 483             {
 484                 typedef typename Set::value_type    value_type;
 485                 typedef typename Set::guarded_ptr   guarded_ptr;
 486
 487                 static size_t const nLimit = 1024;
 488                 value_type arrItems[nLimit];
 489                 int arr[nLimit];
 490                 for ( size_t i = 0; i < nLimit; ++i )
 491                     arr[i] = (int) i;
 492                 std::random_shuffle( arr, arr + nLimit );
 493
 494                 for ( size_t i = 0; i < nLimit; ++i ) {
 495                     arrItems[i].nKey = arr[i];
 496                     arrItems[i].nVal = arr[i] * 2;
 497                 }
 498
 499                 Set s( nLimit, 2 );
 500                 for ( size_t i = 0; i < nLimit; ++i )
 501                     CPPUNIT_ASSERT( s.insert( arrItems[i] ));
 502
 503                 guarded_ptr gp;
 504                 for ( size_t i = 0; i < nLimit; i += 2 ) {
 505                     int nKey = arr[i];
 506                     CPPUNIT_ASSERT( s.get( gp, nKey ));
 507                     CPPUNIT_ASSERT( !gp.empty());
 508                     CPPUNIT_CHECK( gp->nKey == nKey );
 509                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 510
 511                     CPPUNIT_ASSERT( s.extract( gp, nKey ));
 512                     CPPUNIT_ASSERT( !gp.empty() );
 513                     CPPUNIT_CHECK( gp->nKey == nKey );
 514                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 515                     gp.release();
 516
 517                     CPPUNIT_CHECK( !s.get( gp, nKey ));
 518                     CPPUNIT_ASSERT( gp.empty() );
 519                     CPPUNIT_CHECK( !s.extract( gp, nKey ));
 520                     CPPUNIT_CHECK( gp.empty() );
 521
 522                     nKey = arr[i+1];
 523                     CPPUNIT_ASSERT( s.get_with( gp, nKey, less<value_type>() ));
 524                     CPPUNIT_CHECK( gp->nKey == nKey );
 525                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 526
 527                     CPPUNIT_ASSERT( s.extract_with( gp, nKey, less<value_type>() ));
 528                     CPPUNIT_ASSERT( !gp.empty() );
 529                     CPPUNIT_CHECK( gp->nKey == nKey );
 530                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 531                     gp.release();
 532
 533                     CPPUNIT_CHECK( !s.get_with( gp, nKey, less<value_type>() ));
 534                     CPPUNIT_CHECK( gp.empty());
 535                     CPPUNIT_CHECK( !s.extract_with( gp, nKey, less<value_type>() ));
 536                     CPPUNIT_CHECK( gp.empty());
 537                 }
 538                 CPPUNIT_CHECK( s.empty() );
 539                 CPPUNIT_CHECK( check_size( s, 0 ));
 540
 541                 CPPUNIT_CHECK( !s.get( gp, 100 ));
 542                 CPPUNIT_CHECK( !s.extract( gp, 100 ));
 543                 CPPUNIT_CHECK( gp.empty() );
 544
 545                 Set::gc::force_dispose();
 546             }
 547         }
 548
 549         template <class Set>
 550         void test_iter()
 551         {
 552             typedef typename Set::value_type    value_type;
 553             typedef typename Set::iterator set_iterator;
 554             typedef typename Set::iterator const_set_iterator;
 555
 556             value_type  v[500];
 557             {
 558                 Set s( 100, 4 );
 559
 560                 for ( int i = 0; unsigned(i) < sizeof(v)/sizeof(v[0]); ++i ) {
 561                     v[i].nKey = i;
 562                     v[i].nVal = i * 2;
 563
 564                     CPPUNIT_ASSERT( s.insert( v[i] ));
 565                 }
 566
 567                 int nCount = 0;
 568                 for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
 569                     CPPUNIT_ASSERT( (*it).nKey * 2 == it->nVal );
 570                     it->nVal = (*it).nKey;
 571                     ++nCount;
 572                 }
 573                 CPPUNIT_ASSERT( nCount == sizeof(v)/sizeof(v[0]));
 574
 575                 nCount = 0;
 576                 for ( const_set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
 577                     CPPUNIT_ASSERT( (*it).nKey == it->nVal );
 578                     ++nCount;
 579                 }
 580                 CPPUNIT_ASSERT( nCount == sizeof(v)/sizeof(v[0]));
 581
 582                 for ( size_t i = 0; i < sizeof(v)/sizeof(v[0]); ++i ) {
 583                     CPPUNIT_ASSERT( v[i].nKey == v[i].nVal );
 584                 }
 585             }
 586
 587             Set::gc::force_dispose();
 588
 589             for ( size_t i = 0; i < sizeof(v)/sizeof(v[0]); ++i ) {
 590                 CPPUNIT_ASSERT( v[i].nDisposeCount == 1 );
 591             }
 592         }
 593
 594         template <class Set>
 595         void test_int_nogc()
 596         {
 597             typedef typename Set::value_type    value_type;
 598
 599             value_type v1( 10, 50 );
 600             value_type v2( 5, 25  );
 601             value_type v3( 20, 100 );
 602             int key;
 603
 604             {
 605                 {
 606                     Set s( 64, 4 );
 607
 608                     // insert test
 609                     CPPUNIT_ASSERT( s.empty() );
 610                     CPPUNIT_ASSERT( check_size( s, 0 ));
 611
 612                     // insert/find test
 613                     CPPUNIT_ASSERT( s.find( v1.key() ) == nullptr );
 614                     CPPUNIT_ASSERT( s.insert( v1 ));
 615                     CPPUNIT_ASSERT( s.find_with( v1.key(), less<value_type>() ) == &v1 );
 616                     CPPUNIT_ASSERT( check_size( s, 1 ));
 617                     CPPUNIT_ASSERT( !s.empty() );
 618
 619                     CPPUNIT_ASSERT( s.find( v2.key() ) == nullptr );
 620                     CPPUNIT_ASSERT( s.insert( v2 ));
 621                     CPPUNIT_ASSERT( v2.nFindCount == 0 );
 622                     CPPUNIT_ASSERT( s.find( key = v2.key(), find_functor() ));
 623                     CPPUNIT_ASSERT( v2.nFindCount == 1 );
 624                     v2.nFindCount = 0;
 625                     CPPUNIT_ASSERT( check_size( s, 2 ));
 626                     CPPUNIT_ASSERT( !s.empty() );
 627
 628                     {
 629                         find_functor    ff;
 630                         CPPUNIT_ASSERT( s.find( v3 ) == nullptr );
 631                         CPPUNIT_ASSERT( s.insert( v3 ));
 632                         CPPUNIT_ASSERT( v3.nFindCount == 0 );
 633                         CPPUNIT_ASSERT( s.find_with( v3, less<value_type>(), std::ref(ff) ));
 634                         CPPUNIT_ASSERT( v3.nFindCount == 1 );
 635                         v3.nFindCount = 0;
 636                         CPPUNIT_ASSERT( check_size( s, 3 ));
 637                         CPPUNIT_ASSERT( !s.empty() );
 638                     }
 639                 }
 640
 641                 // s.clear()   ; // not all set supports clear() method
 642                 CPPUNIT_ASSERT( v1.nDisposeCount == 1 );
 643                 CPPUNIT_ASSERT( v2.nDisposeCount == 1 );
 644                 CPPUNIT_ASSERT( v3.nDisposeCount == 1 );
 645
 646
 647                 // ensure test
 648                 {
 649                     Set s( 64, 4 );
 650
 651                     ensure_functor f;
 652                     std::pair<bool, bool> ret = s.ensure( v1, f );
 653                     CPPUNIT_ASSERT( ret.first );
 654                     CPPUNIT_ASSERT( ret.second );
 655                     CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 656                     CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
 657                     CPPUNIT_ASSERT( check_size( s, 1 ));
 658
 659                     ret = s.ensure( v2, f );
 660                     CPPUNIT_ASSERT( ret.first );
 661                     CPPUNIT_ASSERT( ret.second );
 662                     CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 663                     CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
 664                     CPPUNIT_ASSERT( check_size( s, 2 ));
 665
 666                     ret = s.ensure( v3, f );
 667                     CPPUNIT_ASSERT( ret.first );
 668                     CPPUNIT_ASSERT( ret.second );
 669                     CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 670                     CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
 671                     CPPUNIT_ASSERT( check_size( s, 3 ));
 672
 673                     CPPUNIT_ASSERT( s.find( v1 ) == &v1 );
 674                     CPPUNIT_ASSERT( s.find( v2 ) == &v2 );
 675                     CPPUNIT_ASSERT( s.find( v3 ) == &v3 );
 676
 677                     ret = s.ensure( v1, f );
 678                     CPPUNIT_ASSERT( ret.first );
 679                     CPPUNIT_ASSERT( !ret.second );
 680                     CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 681                     CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
 682                     CPPUNIT_ASSERT( check_size( s, 3 ));
 683
 684                     ret = s.ensure( v2, f );
 685                     CPPUNIT_ASSERT( ret.first );
 686                     CPPUNIT_ASSERT( !ret.second );
 687                     CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 688                     CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
 689                     CPPUNIT_ASSERT( check_size( s, 3 ));
 690
 691                     ret = s.ensure( v3, f );
 692                     CPPUNIT_ASSERT( ret.first );
 693                     CPPUNIT_ASSERT( !ret.second );
 694                     CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 695                     CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
 696                     CPPUNIT_ASSERT( check_size( s, 3 ));
 697
 698                     CPPUNIT_ASSERT( s.find( v1 ) == &v1 );
 699                     CPPUNIT_ASSERT( s.find( v2 ) == &v2 );
 700                     CPPUNIT_ASSERT( s.find( v3 ) == &v3 );
 701                 }
 702             }
 703
 704             // dispose on destruct test
 705             CPPUNIT_ASSERT( v1.nDisposeCount == 2 );
 706             CPPUNIT_ASSERT( v2.nDisposeCount == 2 );
 707             CPPUNIT_ASSERT( v3.nDisposeCount == 2 );
 708
 709             // Iterator test
 710             test_iter<Set>();
 711         }
 712
 713
 714 #define ASSERT_RCU_FIND( _expr ) { rcu_lock rl; CPPUNIT_ASSERT( _expr ); }
 715         template <class Set>
 716         void test_rcu_int_with( Set& s )
 717         {
 718             typedef typename Set::value_type    value_type;
 719             typedef typename Set::gc::scoped_lock rcu_lock;
 720
 721             value_type v1( 10, 50 );
 722             value_type v2( 5, 25  );
 723             value_type v3( 20, 100 );
 724             value_type v4( 40, 400 );
 725             int key;
 726
 727             CPPUNIT_ASSERT( s.empty() );
 728             CPPUNIT_ASSERT( check_size( s, 0 ));
 729
 730             // insert/find test
 731
 732             ASSERT_RCU_FIND( !s.find_with( v1.key(), less<value_type>() ));
 733             CPPUNIT_ASSERT( s.insert( v1 ));
 734             ASSERT_RCU_FIND( s.find_with( v1.key(), less<value_type>()) );
 735             CPPUNIT_ASSERT( check_size( s, 1 ));
 736             CPPUNIT_ASSERT( !s.empty() );
 737
 738             ASSERT_RCU_FIND( !s.find( v2.key() ));
 739             CPPUNIT_ASSERT( s.insert( v2 ));
 740             CPPUNIT_ASSERT( v2.nFindCount == 0 );
 741             CPPUNIT_ASSERT( s.find( key = v2.key(), find_functor() ));
 742             CPPUNIT_ASSERT( v2.nFindCount == 1 );
 743             v2.nFindCount = 0;
 744             CPPUNIT_ASSERT( check_size( s, 2 ));
 745             CPPUNIT_ASSERT( !s.empty() );
 746
 747             {
 748                 insert_functor  fi;
 749                 find_functor    ff;
 750                 ASSERT_RCU_FIND( !s.find( v3 ));
 751                 CPPUNIT_ASSERT( v3.nVal != v3.nKey * 100 );
 752                 CPPUNIT_ASSERT( s.insert( v3, std::ref(fi) ));
 753                 CPPUNIT_ASSERT( v3.nVal == v3.nKey * 100 );
 754                 CPPUNIT_ASSERT( v3.nFindCount == 0 );
 755                 CPPUNIT_ASSERT( s.find_with( v3, less<value_type>(), std::ref(ff) ));
 756                 CPPUNIT_ASSERT( v3.nFindCount == 1 );
 757                 v3.nFindCount = 0;
 758                 CPPUNIT_ASSERT( check_size( s, 3 ));
 759                 CPPUNIT_ASSERT( !s.empty() );
 760             }
 761
 762             // unlink test
 763             CPPUNIT_ASSERT( s.unlink( v1 ));
 764             ASSERT_RCU_FIND( !s.find( v1 ));
 765             ASSERT_RCU_FIND( s.find( v2 ));
 766             ASSERT_RCU_FIND( s.find( v3 ));
 767             CPPUNIT_ASSERT( check_size( s, 2 ));
 768
 769             CPPUNIT_ASSERT( !s.unlink( v1 ));
 770             ASSERT_RCU_FIND( !s.find( v1 ));
 771             CPPUNIT_ASSERT( check_size( s, 2 ));
 772
 773             ASSERT_RCU_FIND( s.find( v3 ) );
 774             CPPUNIT_ASSERT( s.unlink( v3 ));
 775             ASSERT_RCU_FIND( !s.find( v3 ));
 776             CPPUNIT_ASSERT( check_size( s, 1 ));
 777
 778             ASSERT_RCU_FIND( s.find( v2 ));
 779             CPPUNIT_ASSERT( s.unlink( v2 ));
 780             ASSERT_RCU_FIND( !s.find( v1 ));
 781             ASSERT_RCU_FIND( !s.find( v2 ));
 782             ASSERT_RCU_FIND( !s.find( v3 ));
 783             CPPUNIT_ASSERT( check_size( s, 0 ));
 784             CPPUNIT_ASSERT( s.empty() );
 785
 786             Set::gc::force_dispose();
 787             // unlink function calls disposer
 788             CPPUNIT_ASSERT( v1.nDisposeCount == 1 );
 789             CPPUNIT_ASSERT( v2.nDisposeCount == 1 );
 790             CPPUNIT_ASSERT( v3.nDisposeCount == 1 );
 791
 792             // ensure test
 793             {
 794                 ensure_functor f;
 795                 std::pair<bool, bool> ret = s.ensure( v1, f );
 796                 CPPUNIT_ASSERT( ret.first );
 797                 CPPUNIT_ASSERT( ret.second );
 798                 CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 799                 CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
 800                 CPPUNIT_ASSERT( check_size( s, 1 ));
 801
 802                 ret = s.ensure( v2, f );
 803                 CPPUNIT_ASSERT( ret.first );
 804                 CPPUNIT_ASSERT( ret.second );
 805                 CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 806                 CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
 807                 CPPUNIT_ASSERT( check_size( s, 2 ));
 808
 809                 ret = s.ensure( v3, f );
 810                 CPPUNIT_ASSERT( ret.first );
 811                 CPPUNIT_ASSERT( ret.second );
 812                 CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 813                 CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
 814                 CPPUNIT_ASSERT( check_size( s, 3 ));
 815
 816                 ASSERT_RCU_FIND( s.find( v1 ));
 817                 ASSERT_RCU_FIND( s.find( v2 ));
 818                 ASSERT_RCU_FIND( s.find( v3 ));
 819
 820                 ret = s.ensure( v1, f );
 821                 CPPUNIT_ASSERT( ret.first );
 822                 CPPUNIT_ASSERT( !ret.second );
 823                 CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 824                 CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
 825                 CPPUNIT_ASSERT( check_size( s, 3 ));
 826
 827                 ret = s.ensure( v2, f );
 828                 CPPUNIT_ASSERT( ret.first );
 829                 CPPUNIT_ASSERT( !ret.second );
 830                 CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 831                 CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
 832                 CPPUNIT_ASSERT( check_size( s, 3 ));
 833
 834                 ret = s.ensure( v3, f );
 835                 CPPUNIT_ASSERT( ret.first );
 836                 CPPUNIT_ASSERT( !ret.second );
 837                 CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 838                 CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
 839                 CPPUNIT_ASSERT( check_size( s, 3 ));
 840
 841                 ASSERT_RCU_FIND( s.find( v1 ) );
 842                 ASSERT_RCU_FIND( s.find( v2 ));
 843                 ASSERT_RCU_FIND( s.find( v3 ));
 844             }
 845
 846             // erase test
 847             ASSERT_RCU_FIND( s.find( v1 ));
 848             ASSERT_RCU_FIND( s.find_with( v2, less<value_type>() ));
 849             ASSERT_RCU_FIND( s.find( v3 ));
 850             CPPUNIT_ASSERT( check_size( s, 3 ));
 851             CPPUNIT_ASSERT( !s.empty() );
 852
 853             CPPUNIT_ASSERT( v1.nEraseCount == 0 );
 854             CPPUNIT_ASSERT( s.erase_with( v1, less<value_type>(), erase_functor() ));
 855             CPPUNIT_ASSERT( v1.nEraseCount == 1 );
 856             ASSERT_RCU_FIND( !s.find( v1 ));
 857             ASSERT_RCU_FIND( s.find( v2 ) );
 858             ASSERT_RCU_FIND( s.find( v3 ) );
 859             CPPUNIT_ASSERT( check_size( s, 2 ));
 860             CPPUNIT_ASSERT( !s.empty() );
 861
 862             CPPUNIT_ASSERT( !s.erase( v1 ));
 863             ASSERT_RCU_FIND( !s.find( v1 ));
 864             ASSERT_RCU_FIND( s.find( v2 ));
 865             ASSERT_RCU_FIND( s.find( v3 ) );
 866             CPPUNIT_ASSERT( check_size( s, 2 ));
 867             CPPUNIT_ASSERT( !s.empty() );
 868
 869             ASSERT_RCU_FIND( !s.find( v4 ));
 870             CPPUNIT_ASSERT( s.insert(v4));
 871             ASSERT_RCU_FIND( s.find( v4.key() ));
 872             CPPUNIT_ASSERT( s.erase_with( v4.key(), less<value_type>() ));
 873             ASSERT_RCU_FIND( !s.find( v4.key() ));
 874
 875             CPPUNIT_ASSERT( s.erase( v2.key() ));
 876             ASSERT_RCU_FIND( !s.find( v1 ));
 877             ASSERT_RCU_FIND( !s.find( v2 ));
 878             ASSERT_RCU_FIND( s.find( v3 ) );
 879             CPPUNIT_ASSERT( check_size( s, 1 ));
 880             CPPUNIT_ASSERT( !s.empty() );
 881
 882             CPPUNIT_ASSERT( !s.erase( v2.key() ));
 883             ASSERT_RCU_FIND( !s.find( v1 ));
 884             ASSERT_RCU_FIND( !s.find( v2 ));
 885             ASSERT_RCU_FIND( s.find( v3 ) );
 886             CPPUNIT_ASSERT( check_size( s, 1 ));
 887             CPPUNIT_ASSERT( !s.empty() );
 888
 889             CPPUNIT_ASSERT( v3.nEraseCount == 0 );
 890             CPPUNIT_ASSERT( s.erase( v3, erase_functor() ));
 891             CPPUNIT_ASSERT( v3.nEraseCount == 1 );
 892             ASSERT_RCU_FIND( !s.find( v1 ));
 893             ASSERT_RCU_FIND( !s.find( v2 ));
 894             ASSERT_RCU_FIND( !s.find( v3 ));
 895             CPPUNIT_ASSERT( check_size( s, 0 ));
 896             CPPUNIT_ASSERT( s.empty() );
 897
 898             // dispose test
 899             Set::gc::force_dispose();
 900             CPPUNIT_ASSERT( v1.nDisposeCount == 2 );
 901             CPPUNIT_ASSERT( v2.nDisposeCount == 2 );
 902             CPPUNIT_ASSERT( v3.nDisposeCount == 2 );
 903             CPPUNIT_ASSERT( v4.nDisposeCount == 1 );
 904
 905             CPPUNIT_ASSERT( s.empty() );
 906             CPPUNIT_ASSERT( s.insert( v1 ));
 907             CPPUNIT_ASSERT( s.insert( v3 ));
 908             CPPUNIT_ASSERT( check_size( s, 2 ));
 909             CPPUNIT_ASSERT( !s.empty() );
 910
 911             {
 912                 value_type v( v1 );
 913                 CPPUNIT_ASSERT( !s.unlink( v ) );
 914             }
 915
 916             CPPUNIT_ASSERT( s.unlink( v3 ) );
 917             ASSERT_RCU_FIND( s.find( v1 ));
 918             ASSERT_RCU_FIND( !s.find( v2 ));
 919             ASSERT_RCU_FIND( !s.find( v3 ));
 920             CPPUNIT_ASSERT( check_size( s, 1 ));
 921             CPPUNIT_ASSERT( !s.empty() );
 922
 923             CPPUNIT_ASSERT( !s.unlink( v3 ));
 924             ASSERT_RCU_FIND( s.find( v1 ));
 925             ASSERT_RCU_FIND( !s.find( v2 ));
 926             ASSERT_RCU_FIND( !s.find( v3 ));
 927             CPPUNIT_ASSERT( check_size( s, 1 ));
 928             CPPUNIT_ASSERT( !s.empty() );
 929
 930             CPPUNIT_ASSERT( s.unlink( v1 ));
 931             ASSERT_RCU_FIND( !s.find( v1 ));
 932             ASSERT_RCU_FIND( !s.find( v2 ));
 933             ASSERT_RCU_FIND( !s.find( v3 ));
 934             CPPUNIT_ASSERT( check_size( s, 0 ));
 935             CPPUNIT_ASSERT( s.empty() );
 936
 937             CPPUNIT_ASSERT( !s.unlink( v2 ));
 938             ASSERT_RCU_FIND( !s.find( v1 ));
 939             ASSERT_RCU_FIND( !s.find( v2 ));
 940             ASSERT_RCU_FIND( !s.find( v3 ));
 941             CPPUNIT_ASSERT( check_size( s, 0 ));
 942             CPPUNIT_ASSERT( s.empty() );
 943
 944             Set::gc::force_dispose();
 945             CPPUNIT_ASSERT( v1.nDisposeCount == 3 );
 946             CPPUNIT_ASSERT( v2.nDisposeCount == 2 );
 947             CPPUNIT_ASSERT( v3.nDisposeCount == 3 );
 948             CPPUNIT_ASSERT( v4.nDisposeCount == 1 );
 949
 950             // clear test
 951             CPPUNIT_ASSERT( s.insert( v1 ));
 952             CPPUNIT_ASSERT( s.insert( v3 ));
 953             CPPUNIT_ASSERT( s.insert( v2 ));
 954
 955             s.clear();
 956             Set::gc::force_dispose();
 957             CPPUNIT_ASSERT( v1.nDisposeCount == 4 );
 958             CPPUNIT_ASSERT( v2.nDisposeCount == 3 );
 959             CPPUNIT_ASSERT( v3.nDisposeCount == 4 );
 960             CPPUNIT_ASSERT( v4.nDisposeCount == 1 );
 961         }
 962 #undef ASSERT_RCU_FIND
 963
 964         template <class Set>
 965         void test_rcu_int()
 966         {
 967             {
 968                 Set s( 64, 4 );
 969                 test_rcu_int_with( s );
 970             }
 971
 972             // Iterator test
 973             test_iter<Set>();
 974
 975             // Extract tests
 976             typedef typename Set::gc    rcu;
 977             typedef typename Set::value_type    value_type;
 978             typedef typename Set::rcu_lock      rcu_lock;
 979
 980             typename Set::exempt_ptr ep;
 981
 982             {
 983                 static size_t const nLimit = 1024;
 984                 value_type arrItems[nLimit];
 985                 int arr[nLimit];
 986                 for ( size_t i = 0; i < nLimit; ++i )
 987                     arr[i] = (int) i;
 988                 std::random_shuffle( arr, arr + nLimit );
 989
 990                 for ( size_t i = 0; i < nLimit; ++i ) {
 991                     arrItems[i].nKey = arr[i];
 992                     arrItems[i].nVal = arr[i] * 2;
 993                 }
 994
 995                 Set s( nLimit, 2 );
 996                 for ( size_t i = 0; i < nLimit; ++i )
 997                     CPPUNIT_ASSERT( s.insert( arrItems[i] ));
 998
 999                 for ( size_t i = 0; i < nLimit; i += 2 ) {
1000                     value_type * pVal;
1001                     int nKey = arr[i];
1002                     {
1003                         rcu_lock l;
1004                         pVal = s.get( nKey );
1005                         CPPUNIT_ASSERT( pVal != nullptr );
1006                         CPPUNIT_CHECK( pVal->nKey == nKey );
1007                         CPPUNIT_CHECK( pVal->nVal == nKey * 2 );
1008
1009                         CPPUNIT_ASSERT( s.extract( ep, nKey ));
1010                         CPPUNIT_ASSERT( !ep.empty() );
1011                         CPPUNIT_CHECK( pVal->nKey == ep->nKey );
1012                         CPPUNIT_CHECK( pVal->nVal == (*ep).nVal );
1013                     }
1014                     ep.release();
1015                     {
1016                         rcu_lock l;
1017                         CPPUNIT_CHECK( s.get( nKey ) == nullptr );
1018                         CPPUNIT_CHECK( !s.extract( ep, nKey ));
1019                         CPPUNIT_CHECK( ep.empty() );
1020
1021                         nKey = arr[i+1];
1022                         pVal = s.get_with( nKey, less<value_type>() );
1023                         CPPUNIT_ASSERT( pVal != nullptr );
1024                         CPPUNIT_CHECK( pVal->nKey == nKey );
1025                         CPPUNIT_CHECK( pVal->nVal == nKey * 2 );
1026
1027                         CPPUNIT_ASSERT( s.extract_with( ep, nKey, less<value_type>() ));
1028                         CPPUNIT_ASSERT( !ep.empty() );
1029                         CPPUNIT_CHECK( pVal->nKey == ep->nKey );
1030                         CPPUNIT_CHECK( pVal->nVal == (*ep).nVal );
1031                     }
1032                     ep.release();
1033                     {
1034                         rcu_lock l;
1035                         CPPUNIT_CHECK( s.get_with( nKey, less<value_type>() ) == nullptr );
1036                         CPPUNIT_CHECK( !s.extract_with( ep, nKey, less<value_type>() ));
1037                         CPPUNIT_CHECK( ep.empty() );
1038                     }
1039                 }
1040                 CPPUNIT_CHECK( s.empty() );
1041                 CPPUNIT_CHECK( check_size( s, 0 ));
1042                 {
1043                     rcu_lock l;
1044                     CPPUNIT_CHECK( s.get( 100 ) == nullptr );
1045                     CPPUNIT_CHECK( !s.extract( ep, 100 ));
1046                     CPPUNIT_CHECK( ep.empty() );
1047                 }
1048
1049                 Set::gc::force_dispose();
1050             }
1051         }
1052
1053         // MichaelHashSet + MichaelList
1054         void HP_base_cmp();
1055         void HP_base_less();
1056         void HP_base_cmpmix();
1057         void HP_member_cmp();
1058         void HP_member_less();
1059         void HP_member_cmpmix();
1060
1061         void PTB_base_cmp();
1062         void PTB_base_less();
1063         void PTB_base_cmpmix();
1064         void PTB_member_cmp();
1065         void PTB_member_less();
1066         void PTB_member_cmpmix();
1067
1068         void HRC_base_cmp();
1069         void HRC_base_less();
1070         void HRC_base_cmpmix();
1071
1072         void RCU_GPI_base_cmp();
1073         void RCU_GPI_base_less();
1074         void RCU_GPI_base_cmpmix();
1075         void RCU_GPI_member_cmp();
1076         void RCU_GPI_member_less();
1077         void RCU_GPI_member_cmpmix();
1078
1079         void RCU_GPB_base_cmp();
1080         void RCU_GPB_base_less();
1081         void RCU_GPB_base_cmpmix();
1082         void RCU_GPB_member_cmp();
1083         void RCU_GPB_member_less();
1084         void RCU_GPB_member_cmpmix();
1085
1086         void RCU_GPT_base_cmp();
1087         void RCU_GPT_base_less();
1088         void RCU_GPT_base_cmpmix();
1089         void RCU_GPT_member_cmp();
1090         void RCU_GPT_member_less();
1091         void RCU_GPT_member_cmpmix();
1092
1093         void RCU_SHB_base_cmp();
1094         void RCU_SHB_base_less();
1095         void RCU_SHB_base_cmpmix();
1096         void RCU_SHB_member_cmp();
1097         void RCU_SHB_member_less();
1098         void RCU_SHB_member_cmpmix();
1099
1100         void RCU_SHT_base_cmp();
1101         void RCU_SHT_base_less();
1102         void RCU_SHT_base_cmpmix();
1103         void RCU_SHT_member_cmp();
1104         void RCU_SHT_member_less();
1105         void RCU_SHT_member_cmpmix();
1106
1107         void nogc_base_cmp();
1108         void nogc_base_less();
1109         void nogc_base_cmpmix();
1110         void nogc_member_cmp();
1111         void nogc_member_less();
1112         void nogc_member_cmpmix();
1113
1114         // MichaelHashSet + LazyList
1115         void HP_base_cmp_lazy();
1116         void HP_base_less_lazy();
1117         void HP_base_cmpmix_lazy();
1118         void HP_member_cmp_lazy();
1119         void HP_member_less_lazy();
1120         void HP_member_cmpmix_lazy();
1121
1122         void PTB_base_cmp_lazy();
1123         void PTB_base_less_lazy();
1124         void PTB_base_cmpmix_lazy();
1125         void PTB_member_cmp_lazy();
1126         void PTB_member_less_lazy();
1127         void PTB_member_cmpmix_lazy();
1128
1129         void HRC_base_cmp_lazy();
1130         void HRC_base_less_lazy();
1131         void HRC_base_cmpmix_lazy();
1132
1133         void RCU_GPI_base_cmp_lazy();
1134         void RCU_GPI_base_less_lazy();
1135         void RCU_GPI_base_cmpmix_lazy();
1136         void RCU_GPI_member_cmp_lazy();
1137         void RCU_GPI_member_less_lazy();
1138         void RCU_GPI_member_cmpmix_lazy();
1139
1140         void RCU_GPB_base_cmp_lazy();
1141         void RCU_GPB_base_less_lazy();
1142         void RCU_GPB_base_cmpmix_lazy();
1143         void RCU_GPB_member_cmp_lazy();
1144         void RCU_GPB_member_less_lazy();
1145         void RCU_GPB_member_cmpmix_lazy();
1146
1147         void RCU_GPT_base_cmp_lazy();
1148         void RCU_GPT_base_less_lazy();
1149         void RCU_GPT_base_cmpmix_lazy();
1150         void RCU_GPT_member_cmp_lazy();
1151         void RCU_GPT_member_less_lazy();
1152         void RCU_GPT_member_cmpmix_lazy();
1153
1154         void RCU_SHB_base_cmp_lazy();
1155         void RCU_SHB_base_less_lazy();
1156         void RCU_SHB_base_cmpmix_lazy();
1157         void RCU_SHB_member_cmp_lazy();
1158         void RCU_SHB_member_less_lazy();
1159         void RCU_SHB_member_cmpmix_lazy();
1160
1161         void RCU_SHT_base_cmp_lazy();
1162         void RCU_SHT_base_less_lazy();
1163         void RCU_SHT_base_cmpmix_lazy();
1164         void RCU_SHT_member_cmp_lazy();
1165         void RCU_SHT_member_less_lazy();
1166         void RCU_SHT_member_cmpmix_lazy();
1167
1168         void nogc_base_cmp_lazy();
1169         void nogc_base_less_lazy();
1170         void nogc_base_cmpmix_lazy();
1171         void nogc_member_cmp_lazy();
1172         void nogc_member_less_lazy();
1173         void nogc_member_cmpmix_lazy();
1174
1175         // SplitListSet + MichaelList [dyn - dynamic bucket table, st - static bucket table]
1176         void split_dyn_HP_base_cmp();
1177         void split_dyn_HP_base_less();
1178         void split_dyn_HP_base_cmpmix();
1179         void split_dyn_HP_member_cmp();
1180         void split_dyn_HP_member_less();
1181         void split_dyn_HP_member_cmpmix();
1182         void split_st_HP_base_cmp();
1183         void split_st_HP_base_less();
1184         void split_st_HP_base_cmpmix();
1185         void split_st_HP_member_cmp();
1186         void split_st_HP_member_less();
1187         void split_st_HP_member_cmpmix();
1188
1189         void split_dyn_PTB_base_cmp();
1190         void split_dyn_PTB_base_less();
1191         void split_dyn_PTB_base_cmpmix();
1192         void split_dyn_PTB_member_cmp();
1193         void split_dyn_PTB_member_less();
1194         void split_dyn_PTB_member_cmpmix();
1195         void split_st_PTB_base_cmp();
1196         void split_st_PTB_base_less();
1197         void split_st_PTB_base_cmpmix();
1198         void split_st_PTB_member_cmp();
1199         void split_st_PTB_member_less();
1200         void split_st_PTB_member_cmpmix();
1201
1202         void split_dyn_HRC_base_cmp();
1203         void split_dyn_HRC_base_less();
1204         void split_dyn_HRC_base_cmpmix();
1205         void split_st_HRC_base_cmp();
1206         void split_st_HRC_base_less();
1207         void split_st_HRC_base_cmpmix();
1208
1209         void split_dyn_RCU_GPI_base_cmp();
1210         void split_dyn_RCU_GPI_base_less();
1211         void split_dyn_RCU_GPI_base_cmpmix();
1212         void split_dyn_RCU_GPI_member_cmp();
1213         void split_dyn_RCU_GPI_member_less();
1214         void split_dyn_RCU_GPI_member_cmpmix();
1215         void split_st_RCU_GPI_base_cmp();
1216         void split_st_RCU_GPI_base_less();
1217         void split_st_RCU_GPI_base_cmpmix();
1218         void split_st_RCU_GPI_member_cmp();
1219         void split_st_RCU_GPI_member_less();
1220         void split_st_RCU_GPI_member_cmpmix();
1221
1222         void split_dyn_RCU_GPB_base_cmp();
1223         void split_dyn_RCU_GPB_base_less();
1224         void split_dyn_RCU_GPB_base_cmpmix();
1225         void split_dyn_RCU_GPB_member_cmp();
1226         void split_dyn_RCU_GPB_member_less();
1227         void split_dyn_RCU_GPB_member_cmpmix();
1228         void split_st_RCU_GPB_base_cmp();
1229         void split_st_RCU_GPB_base_less();
1230         void split_st_RCU_GPB_base_cmpmix();
1231         void split_st_RCU_GPB_member_cmp();
1232         void split_st_RCU_GPB_member_less();
1233         void split_st_RCU_GPB_member_cmpmix();
1234
1235         void split_dyn_RCU_GPT_base_cmp();
1236         void split_dyn_RCU_GPT_base_less();
1237         void split_dyn_RCU_GPT_base_cmpmix();
1238         void split_dyn_RCU_GPT_member_cmp();
1239         void split_dyn_RCU_GPT_member_less();
1240         void split_dyn_RCU_GPT_member_cmpmix();
1241         void split_st_RCU_GPT_base_cmp();
1242         void split_st_RCU_GPT_base_less();
1243         void split_st_RCU_GPT_base_cmpmix();
1244         void split_st_RCU_GPT_member_cmp();
1245         void split_st_RCU_GPT_member_less();
1246         void split_st_RCU_GPT_member_cmpmix();
1247
1248         void split_dyn_RCU_SHB_base_cmp();
1249         void split_dyn_RCU_SHB_base_less();
1250         void split_dyn_RCU_SHB_base_cmpmix();
1251         void split_dyn_RCU_SHB_member_cmp();
1252         void split_dyn_RCU_SHB_member_less();
1253         void split_dyn_RCU_SHB_member_cmpmix();
1254         void split_st_RCU_SHB_base_cmp();
1255         void split_st_RCU_SHB_base_less();
1256         void split_st_RCU_SHB_base_cmpmix();
1257         void split_st_RCU_SHB_member_cmp();
1258         void split_st_RCU_SHB_member_less();
1259         void split_st_RCU_SHB_member_cmpmix();
1260
1261         void split_dyn_RCU_SHT_base_cmp();
1262         void split_dyn_RCU_SHT_base_less();
1263         void split_dyn_RCU_SHT_base_cmpmix();
1264         void split_dyn_RCU_SHT_member_cmp();
1265         void split_dyn_RCU_SHT_member_less();
1266         void split_dyn_RCU_SHT_member_cmpmix();
1267         void split_st_RCU_SHT_base_cmp();
1268         void split_st_RCU_SHT_base_less();
1269         void split_st_RCU_SHT_base_cmpmix();
1270         void split_st_RCU_SHT_member_cmp();
1271         void split_st_RCU_SHT_member_less();
1272         void split_st_RCU_SHT_member_cmpmix();
1273
1274         void split_dyn_nogc_base_cmp();
1275         void split_dyn_nogc_base_less();
1276         void split_dyn_nogc_base_cmpmix();
1277         void split_dyn_nogc_member_cmp();
1278         void split_dyn_nogc_member_less();
1279         void split_dyn_nogc_member_cmpmix();
1280         void split_st_nogc_base_cmp();
1281         void split_st_nogc_base_less();
1282         void split_st_nogc_base_cmpmix();
1283         void split_st_nogc_member_cmp();
1284         void split_st_nogc_member_less();
1285         void split_st_nogc_member_cmpmix();
1286
1287
1288         // SplitListSet + LazyList [dyn - dynamic bucket table, st - static bucket table]
1289         void split_dyn_HP_base_cmp_lazy();
1290         void split_dyn_HP_base_less_lazy();
1291         void split_dyn_HP_base_cmpmix_lazy();
1292         void split_dyn_HP_member_cmp_lazy();
1293         void split_dyn_HP_member_less_lazy();
1294         void split_dyn_HP_member_cmpmix_lazy();
1295         void split_st_HP_base_cmp_lazy();
1296         void split_st_HP_base_less_lazy();
1297         void split_st_HP_base_cmpmix_lazy();
1298         void split_st_HP_member_cmp_lazy();
1299         void split_st_HP_member_less_lazy();
1300         void split_st_HP_member_cmpmix_lazy();
1301
1302         void split_dyn_PTB_base_cmp_lazy();
1303         void split_dyn_PTB_base_less_lazy();
1304         void split_dyn_PTB_base_cmpmix_lazy();
1305         void split_dyn_PTB_member_cmp_lazy();
1306         void split_dyn_PTB_member_less_lazy();
1307         void split_dyn_PTB_member_cmpmix_lazy();
1308         void split_st_PTB_base_cmp_lazy();
1309         void split_st_PTB_base_less_lazy();
1310         void split_st_PTB_base_cmpmix_lazy();
1311         void split_st_PTB_member_cmp_lazy();
1312         void split_st_PTB_member_less_lazy();
1313         void split_st_PTB_member_cmpmix_lazy();
1314
1315         void split_dyn_HRC_base_cmp_lazy();
1316         void split_dyn_HRC_base_less_lazy();
1317         void split_dyn_HRC_base_cmpmix_lazy();
1318         void split_st_HRC_base_cmp_lazy();
1319         void split_st_HRC_base_less_lazy();
1320         void split_st_HRC_base_cmpmix_lazy();
1321
1322         void split_dyn_RCU_GPI_base_cmp_lazy();
1323         void split_dyn_RCU_GPI_base_less_lazy();
1324         void split_dyn_RCU_GPI_base_cmpmix_lazy();
1325         void split_dyn_RCU_GPI_member_cmp_lazy();
1326         void split_dyn_RCU_GPI_member_less_lazy();
1327         void split_dyn_RCU_GPI_member_cmpmix_lazy();
1328         void split_st_RCU_GPI_base_cmp_lazy();
1329         void split_st_RCU_GPI_base_less_lazy();
1330         void split_st_RCU_GPI_base_cmpmix_lazy();
1331         void split_st_RCU_GPI_member_cmp_lazy();
1332         void split_st_RCU_GPI_member_less_lazy();
1333         void split_st_RCU_GPI_member_cmpmix_lazy();
1334
1335         void split_dyn_RCU_GPB_base_cmp_lazy();
1336         void split_dyn_RCU_GPB_base_less_lazy();
1337         void split_dyn_RCU_GPB_base_cmpmix_lazy();
1338         void split_dyn_RCU_GPB_member_cmp_lazy();
1339         void split_dyn_RCU_GPB_member_less_lazy();
1340         void split_dyn_RCU_GPB_member_cmpmix_lazy();
1341         void split_st_RCU_GPB_base_cmp_lazy();
1342         void split_st_RCU_GPB_base_less_lazy();
1343         void split_st_RCU_GPB_base_cmpmix_lazy();
1344         void split_st_RCU_GPB_member_cmp_lazy();
1345         void split_st_RCU_GPB_member_less_lazy();
1346         void split_st_RCU_GPB_member_cmpmix_lazy();
1347
1348         void split_dyn_RCU_GPT_base_cmp_lazy();
1349         void split_dyn_RCU_GPT_base_less_lazy();
1350         void split_dyn_RCU_GPT_base_cmpmix_lazy();
1351         void split_dyn_RCU_GPT_member_cmp_lazy();
1352         void split_dyn_RCU_GPT_member_less_lazy();
1353         void split_dyn_RCU_GPT_member_cmpmix_lazy();
1354         void split_st_RCU_GPT_base_cmp_lazy();
1355         void split_st_RCU_GPT_base_less_lazy();
1356         void split_st_RCU_GPT_base_cmpmix_lazy();
1357         void split_st_RCU_GPT_member_cmp_lazy();
1358         void split_st_RCU_GPT_member_less_lazy();
1359         void split_st_RCU_GPT_member_cmpmix_lazy();
1360
1361         void split_dyn_RCU_SHB_base_cmp_lazy();
1362         void split_dyn_RCU_SHB_base_less_lazy();
1363         void split_dyn_RCU_SHB_base_cmpmix_lazy();
1364         void split_dyn_RCU_SHB_member_cmp_lazy();
1365         void split_dyn_RCU_SHB_member_less_lazy();
1366         void split_dyn_RCU_SHB_member_cmpmix_lazy();
1367         void split_st_RCU_SHB_base_cmp_lazy();
1368         void split_st_RCU_SHB_base_less_lazy();
1369         void split_st_RCU_SHB_base_cmpmix_lazy();
1370         void split_st_RCU_SHB_member_cmp_lazy();
1371         void split_st_RCU_SHB_member_less_lazy();
1372         void split_st_RCU_SHB_member_cmpmix_lazy();
1373
1374         void split_dyn_RCU_SHT_base_cmp_lazy();
1375         void split_dyn_RCU_SHT_base_less_lazy();
1376         void split_dyn_RCU_SHT_base_cmpmix_lazy();
1377         void split_dyn_RCU_SHT_member_cmp_lazy();
1378         void split_dyn_RCU_SHT_member_less_lazy();
1379         void split_dyn_RCU_SHT_member_cmpmix_lazy();
1380         void split_st_RCU_SHT_base_cmp_lazy();
1381         void split_st_RCU_SHT_base_less_lazy();
1382         void split_st_RCU_SHT_base_cmpmix_lazy();
1383         void split_st_RCU_SHT_member_cmp_lazy();
1384         void split_st_RCU_SHT_member_less_lazy();
1385         void split_st_RCU_SHT_member_cmpmix_lazy();
1386
1387         void split_dyn_nogc_base_cmp_lazy();
1388         void split_dyn_nogc_base_less_lazy();
1389         void split_dyn_nogc_base_cmpmix_lazy();
1390         void split_dyn_nogc_member_cmp_lazy();
1391         void split_dyn_nogc_member_less_lazy();
1392         void split_dyn_nogc_member_cmpmix_lazy();
1393         void split_st_nogc_base_cmp_lazy();
1394         void split_st_nogc_base_less_lazy();
1395         void split_st_nogc_base_cmpmix_lazy();
1396         void split_st_nogc_member_cmp_lazy();
1397         void split_st_nogc_member_less_lazy();
1398         void split_st_nogc_member_cmpmix_lazy();
1399
1400         CPPUNIT_TEST_SUITE(IntrusiveHashSetHdrTest)
1401             CPPUNIT_TEST(HP_base_cmp)
1402             CPPUNIT_TEST(HP_base_less)
1403             CPPUNIT_TEST(HP_base_cmpmix)
1404             CPPUNIT_TEST(HP_member_cmp)
1405             CPPUNIT_TEST(HP_member_less)
1406             CPPUNIT_TEST(HP_member_cmpmix)
1407
1408             CPPUNIT_TEST(PTB_base_cmp)
1409             CPPUNIT_TEST(PTB_base_less)
1410             CPPUNIT_TEST(PTB_base_cmpmix)
1411             CPPUNIT_TEST(PTB_member_cmp)
1412             CPPUNIT_TEST(PTB_member_less)
1413             CPPUNIT_TEST(PTB_member_cmpmix)
1414
1415             CPPUNIT_TEST(HRC_base_cmp)
1416             CPPUNIT_TEST(HRC_base_less)
1417             CPPUNIT_TEST(HRC_base_cmpmix)
1418
1419             CPPUNIT_TEST(RCU_GPI_base_cmp)
1420             CPPUNIT_TEST(RCU_GPI_base_less)
1421             CPPUNIT_TEST(RCU_GPI_base_cmpmix)
1422             CPPUNIT_TEST(RCU_GPI_member_cmp)
1423             CPPUNIT_TEST(RCU_GPI_member_less)
1424             CPPUNIT_TEST(RCU_GPI_member_cmpmix)
1425
1426             CPPUNIT_TEST(RCU_GPB_base_cmp)
1427             CPPUNIT_TEST(RCU_GPB_base_less)
1428             CPPUNIT_TEST(RCU_GPB_base_cmpmix)
1429             CPPUNIT_TEST(RCU_GPB_member_cmp)
1430             CPPUNIT_TEST(RCU_GPB_member_less)
1431             CPPUNIT_TEST(RCU_GPB_member_cmpmix)
1432
1433             CPPUNIT_TEST(RCU_GPT_base_cmp)
1434             CPPUNIT_TEST(RCU_GPT_base_less)
1435             CPPUNIT_TEST(RCU_GPT_base_cmpmix)
1436             CPPUNIT_TEST(RCU_GPT_member_cmp)
1437             CPPUNIT_TEST(RCU_GPT_member_less)
1438             CPPUNIT_TEST(RCU_GPT_member_cmpmix)
1439
1440             CPPUNIT_TEST(RCU_SHB_base_cmp)
1441             CPPUNIT_TEST(RCU_SHB_base_less)
1442             CPPUNIT_TEST(RCU_SHB_base_cmpmix)
1443             CPPUNIT_TEST(RCU_SHB_member_cmp)
1444             CPPUNIT_TEST(RCU_SHB_member_less)
1445             CPPUNIT_TEST(RCU_SHB_member_cmpmix)
1446
1447             CPPUNIT_TEST(RCU_SHT_base_cmp)
1448             CPPUNIT_TEST(RCU_SHT_base_less)
1449             CPPUNIT_TEST(RCU_SHT_base_cmpmix)
1450             CPPUNIT_TEST(RCU_SHT_member_cmp)
1451             CPPUNIT_TEST(RCU_SHT_member_less)
1452             CPPUNIT_TEST(RCU_SHT_member_cmpmix)
1453
1454             CPPUNIT_TEST(nogc_base_cmp)
1455             CPPUNIT_TEST(nogc_base_less)
1456             CPPUNIT_TEST(nogc_base_cmpmix)
1457             CPPUNIT_TEST(nogc_member_cmp)
1458             CPPUNIT_TEST(nogc_member_less)
1459             CPPUNIT_TEST(nogc_member_cmpmix)
1460
1461             CPPUNIT_TEST(HP_base_cmp_lazy)
1462             CPPUNIT_TEST(HP_base_less_lazy)
1463             CPPUNIT_TEST(HP_base_cmpmix_lazy)
1464             CPPUNIT_TEST(HP_member_cmp_lazy)
1465             CPPUNIT_TEST(HP_member_less_lazy)
1466             CPPUNIT_TEST(HP_member_cmpmix_lazy)
1467
1468             CPPUNIT_TEST(PTB_base_cmp_lazy)
1469             CPPUNIT_TEST(PTB_base_less_lazy)
1470             CPPUNIT_TEST(PTB_base_cmpmix_lazy)
1471             CPPUNIT_TEST(PTB_member_cmp_lazy)
1472             CPPUNIT_TEST(PTB_member_less_lazy)
1473             CPPUNIT_TEST(PTB_member_cmpmix_lazy)
1474
1475             CPPUNIT_TEST(HRC_base_cmp_lazy)
1476             CPPUNIT_TEST(HRC_base_less_lazy)
1477             CPPUNIT_TEST(HRC_base_cmpmix_lazy)
1478
1479             CPPUNIT_TEST(RCU_GPI_base_cmp_lazy)
1480             CPPUNIT_TEST(RCU_GPI_base_less_lazy)
1481             CPPUNIT_TEST(RCU_GPI_base_cmpmix_lazy)
1482             CPPUNIT_TEST(RCU_GPI_member_cmp_lazy)
1483             CPPUNIT_TEST(RCU_GPI_member_less_lazy)
1484             CPPUNIT_TEST(RCU_GPI_member_cmpmix_lazy)
1485
1486             CPPUNIT_TEST(RCU_GPB_base_cmp_lazy)
1487             CPPUNIT_TEST(RCU_GPB_base_less_lazy)
1488             CPPUNIT_TEST(RCU_GPB_base_cmpmix_lazy)
1489             CPPUNIT_TEST(RCU_GPB_member_cmp_lazy)
1490             CPPUNIT_TEST(RCU_GPB_member_less_lazy)
1491             CPPUNIT_TEST(RCU_GPB_member_cmpmix_lazy)
1492
1493             CPPUNIT_TEST(RCU_GPT_base_cmp_lazy)
1494             CPPUNIT_TEST(RCU_GPT_base_less_lazy)
1495             CPPUNIT_TEST(RCU_GPT_base_cmpmix_lazy)
1496             CPPUNIT_TEST(RCU_GPT_member_cmp_lazy)
1497             CPPUNIT_TEST(RCU_GPT_member_less_lazy)
1498             CPPUNIT_TEST(RCU_GPT_member_cmpmix_lazy)
1499
1500             CPPUNIT_TEST(RCU_SHB_base_cmp_lazy)
1501             CPPUNIT_TEST(RCU_SHB_base_less_lazy)
1502             CPPUNIT_TEST(RCU_SHB_base_cmpmix_lazy)
1503             CPPUNIT_TEST(RCU_SHB_member_cmp_lazy)
1504             CPPUNIT_TEST(RCU_SHB_member_less_lazy)
1505             CPPUNIT_TEST(RCU_SHB_member_cmpmix_lazy)
1506
1507             CPPUNIT_TEST(RCU_SHT_base_cmp_lazy)
1508             CPPUNIT_TEST(RCU_SHT_base_less_lazy)
1509             CPPUNIT_TEST(RCU_SHT_base_cmpmix_lazy)
1510             CPPUNIT_TEST(RCU_SHT_member_cmp_lazy)
1511             CPPUNIT_TEST(RCU_SHT_member_less_lazy)
1512             CPPUNIT_TEST(RCU_SHT_member_cmpmix_lazy)
1513
1514             CPPUNIT_TEST(nogc_base_cmp_lazy)
1515             CPPUNIT_TEST(nogc_base_less_lazy)
1516             CPPUNIT_TEST(nogc_base_cmpmix_lazy)
1517             CPPUNIT_TEST(nogc_member_cmp_lazy)
1518             CPPUNIT_TEST(nogc_member_less_lazy)
1519             CPPUNIT_TEST(nogc_member_cmpmix_lazy)
1520
1521             CPPUNIT_TEST(split_dyn_HP_base_cmp)
1522             CPPUNIT_TEST(split_dyn_HP_base_less)
1523             CPPUNIT_TEST(split_dyn_HP_base_cmpmix)
1524             CPPUNIT_TEST(split_dyn_HP_member_cmp)
1525             CPPUNIT_TEST(split_dyn_HP_member_less)
1526             CPPUNIT_TEST(split_dyn_HP_member_cmpmix)
1527             CPPUNIT_TEST(split_st_HP_base_cmp)
1528             CPPUNIT_TEST(split_st_HP_base_less)
1529             CPPUNIT_TEST(split_st_HP_base_cmpmix)
1530             CPPUNIT_TEST(split_st_HP_member_cmp)
1531             CPPUNIT_TEST(split_st_HP_member_less)
1532             CPPUNIT_TEST(split_st_HP_member_cmpmix)
1533
1534             CPPUNIT_TEST(split_dyn_PTB_base_cmp)
1535             CPPUNIT_TEST(split_dyn_PTB_base_less)
1536             CPPUNIT_TEST(split_dyn_PTB_base_cmpmix)
1537             CPPUNIT_TEST(split_dyn_PTB_member_cmp)
1538             CPPUNIT_TEST(split_dyn_PTB_member_less)
1539             CPPUNIT_TEST(split_dyn_PTB_member_cmpmix)
1540             CPPUNIT_TEST(split_st_PTB_base_cmp)
1541             CPPUNIT_TEST(split_st_PTB_base_less)
1542             CPPUNIT_TEST(split_st_PTB_base_cmpmix)
1543             CPPUNIT_TEST(split_st_PTB_member_cmp)
1544             CPPUNIT_TEST(split_st_PTB_member_less)
1545             CPPUNIT_TEST(split_st_PTB_member_cmpmix)
1546
1547             CPPUNIT_TEST(split_dyn_HRC_base_cmp)
1548             CPPUNIT_TEST(split_dyn_HRC_base_less)
1549             CPPUNIT_TEST(split_dyn_HRC_base_cmpmix)
1550             CPPUNIT_TEST(split_st_HRC_base_cmp)
1551             CPPUNIT_TEST(split_st_HRC_base_less)
1552             CPPUNIT_TEST(split_st_HRC_base_cmpmix)
1553
1554             CPPUNIT_TEST(split_dyn_RCU_GPI_base_cmp)
1555             CPPUNIT_TEST(split_dyn_RCU_GPI_base_less)
1556             CPPUNIT_TEST(split_dyn_RCU_GPI_base_cmpmix)
1557             CPPUNIT_TEST(split_dyn_RCU_GPI_member_cmp)
1558             CPPUNIT_TEST(split_dyn_RCU_GPI_member_less)
1559             CPPUNIT_TEST(split_dyn_RCU_GPI_member_cmpmix)
1560             CPPUNIT_TEST(split_st_RCU_GPI_base_cmp)
1561             CPPUNIT_TEST(split_st_RCU_GPI_base_less)
1562             CPPUNIT_TEST(split_st_RCU_GPI_base_cmpmix)
1563             CPPUNIT_TEST(split_st_RCU_GPI_member_cmp)
1564             CPPUNIT_TEST(split_st_RCU_GPI_member_less)
1565             CPPUNIT_TEST(split_st_RCU_GPI_member_cmpmix)
1566
1567             CPPUNIT_TEST(split_dyn_RCU_GPB_base_cmp)
1568             CPPUNIT_TEST(split_dyn_RCU_GPB_base_less)
1569             CPPUNIT_TEST(split_dyn_RCU_GPB_base_cmpmix)
1570             CPPUNIT_TEST(split_dyn_RCU_GPB_member_cmp)
1571             CPPUNIT_TEST(split_dyn_RCU_GPB_member_less)
1572             CPPUNIT_TEST(split_dyn_RCU_GPB_member_cmpmix)
1573             CPPUNIT_TEST(split_st_RCU_GPB_base_cmp)
1574             CPPUNIT_TEST(split_st_RCU_GPB_base_less)
1575             CPPUNIT_TEST(split_st_RCU_GPB_base_cmpmix)
1576             CPPUNIT_TEST(split_st_RCU_GPB_member_cmp)
1577             CPPUNIT_TEST(split_st_RCU_GPB_member_less)
1578             CPPUNIT_TEST(split_st_RCU_GPB_member_cmpmix)
1579
1580             CPPUNIT_TEST(split_dyn_RCU_GPT_base_cmp)
1581             CPPUNIT_TEST(split_dyn_RCU_GPT_base_less)
1582             CPPUNIT_TEST(split_dyn_RCU_GPT_base_cmpmix)
1583             CPPUNIT_TEST(split_dyn_RCU_GPT_member_cmp)
1584             CPPUNIT_TEST(split_dyn_RCU_GPT_member_less)
1585             CPPUNIT_TEST(split_dyn_RCU_GPT_member_cmpmix)
1586             CPPUNIT_TEST(split_st_RCU_GPT_base_cmp)
1587             CPPUNIT_TEST(split_st_RCU_GPT_base_less)
1588             CPPUNIT_TEST(split_st_RCU_GPT_base_cmpmix)
1589             CPPUNIT_TEST(split_st_RCU_GPT_member_cmp)
1590             CPPUNIT_TEST(split_st_RCU_GPT_member_less)
1591             CPPUNIT_TEST(split_st_RCU_GPT_member_cmpmix)
1592
1593             CPPUNIT_TEST(split_dyn_RCU_SHB_base_cmp)
1594             CPPUNIT_TEST(split_dyn_RCU_SHB_base_less)
1595             CPPUNIT_TEST(split_dyn_RCU_SHB_base_cmpmix)
1596             CPPUNIT_TEST(split_dyn_RCU_SHB_member_cmp)
1597             CPPUNIT_TEST(split_dyn_RCU_SHB_member_less)
1598             CPPUNIT_TEST(split_dyn_RCU_SHB_member_cmpmix)
1599             CPPUNIT_TEST(split_st_RCU_SHB_base_cmp)
1600             CPPUNIT_TEST(split_st_RCU_SHB_base_less)
1601             CPPUNIT_TEST(split_st_RCU_SHB_base_cmpmix)
1602             CPPUNIT_TEST(split_st_RCU_SHB_member_cmp)
1603             CPPUNIT_TEST(split_st_RCU_SHB_member_less)
1604             CPPUNIT_TEST(split_st_RCU_SHB_member_cmpmix)
1605
1606             CPPUNIT_TEST(split_dyn_RCU_SHT_base_cmp)
1607             CPPUNIT_TEST(split_dyn_RCU_SHT_base_less)
1608             CPPUNIT_TEST(split_dyn_RCU_SHT_base_cmpmix)
1609             CPPUNIT_TEST(split_dyn_RCU_SHT_member_cmp)
1610             CPPUNIT_TEST(split_dyn_RCU_SHT_member_less)
1611             CPPUNIT_TEST(split_dyn_RCU_SHT_member_cmpmix)
1612             CPPUNIT_TEST(split_st_RCU_SHT_base_cmp)
1613             CPPUNIT_TEST(split_st_RCU_SHT_base_less)
1614             CPPUNIT_TEST(split_st_RCU_SHT_base_cmpmix)
1615             CPPUNIT_TEST(split_st_RCU_SHT_member_cmp)
1616             CPPUNIT_TEST(split_st_RCU_SHT_member_less)
1617             CPPUNIT_TEST(split_st_RCU_SHT_member_cmpmix)
1618
1619             CPPUNIT_TEST(split_dyn_nogc_base_cmp)
1620             CPPUNIT_TEST(split_dyn_nogc_base_less)
1621             CPPUNIT_TEST(split_dyn_nogc_base_cmpmix)
1622             CPPUNIT_TEST(split_dyn_nogc_member_cmp)
1623             CPPUNIT_TEST(split_dyn_nogc_member_less)
1624             CPPUNIT_TEST(split_dyn_nogc_member_cmpmix)
1625             CPPUNIT_TEST(split_st_nogc_base_cmp)
1626             CPPUNIT_TEST(split_st_nogc_base_less)
1627             CPPUNIT_TEST(split_st_nogc_base_cmpmix)
1628             CPPUNIT_TEST(split_st_nogc_member_cmp)
1629             CPPUNIT_TEST(split_st_nogc_member_less)
1630             CPPUNIT_TEST(split_st_nogc_member_cmpmix)
1631
1632
1633             CPPUNIT_TEST(split_dyn_HP_base_cmp_lazy)
1634             CPPUNIT_TEST(split_dyn_HP_base_less_lazy)
1635             CPPUNIT_TEST(split_dyn_HP_base_cmpmix_lazy)
1636             CPPUNIT_TEST(split_dyn_HP_member_cmp_lazy)
1637             CPPUNIT_TEST(split_dyn_HP_member_less_lazy)
1638             CPPUNIT_TEST(split_dyn_HP_member_cmpmix_lazy)
1639             CPPUNIT_TEST(split_st_HP_base_cmp_lazy)
1640             CPPUNIT_TEST(split_st_HP_base_less_lazy)
1641             CPPUNIT_TEST(split_st_HP_base_cmpmix_lazy)
1642             CPPUNIT_TEST(split_st_HP_member_cmp_lazy)
1643             CPPUNIT_TEST(split_st_HP_member_less_lazy)
1644             CPPUNIT_TEST(split_st_HP_member_cmpmix_lazy)
1645
1646             CPPUNIT_TEST(split_dyn_PTB_base_cmp_lazy)
1647             CPPUNIT_TEST(split_dyn_PTB_base_less_lazy)
1648             CPPUNIT_TEST(split_dyn_PTB_base_cmpmix_lazy)
1649             CPPUNIT_TEST(split_dyn_PTB_member_cmp_lazy)
1650             CPPUNIT_TEST(split_dyn_PTB_member_less_lazy)
1651             CPPUNIT_TEST(split_dyn_PTB_member_cmpmix_lazy)
1652             CPPUNIT_TEST(split_st_PTB_base_cmp_lazy)
1653             CPPUNIT_TEST(split_st_PTB_base_less_lazy)
1654             CPPUNIT_TEST(split_st_PTB_base_cmpmix_lazy)
1655             CPPUNIT_TEST(split_st_PTB_member_cmp_lazy)
1656             CPPUNIT_TEST(split_st_PTB_member_less_lazy)
1657             CPPUNIT_TEST(split_st_PTB_member_cmpmix_lazy)
1658
1659             CPPUNIT_TEST(split_dyn_HRC_base_cmp_lazy)
1660             CPPUNIT_TEST(split_dyn_HRC_base_less_lazy)
1661             CPPUNIT_TEST(split_dyn_HRC_base_cmpmix_lazy)
1662             CPPUNIT_TEST(split_st_HRC_base_cmp_lazy)
1663             CPPUNIT_TEST(split_st_HRC_base_less_lazy)
1664             CPPUNIT_TEST(split_st_HRC_base_cmpmix_lazy)
1665
1666             CPPUNIT_TEST(split_dyn_RCU_GPI_base_cmp_lazy)
1667             CPPUNIT_TEST(split_dyn_RCU_GPI_base_less_lazy)
1668             CPPUNIT_TEST(split_dyn_RCU_GPI_base_cmpmix_lazy)
1669             CPPUNIT_TEST(split_dyn_RCU_GPI_member_cmp_lazy)
1670             CPPUNIT_TEST(split_dyn_RCU_GPI_member_less_lazy)
1671             CPPUNIT_TEST(split_dyn_RCU_GPI_member_cmpmix_lazy)
1672             CPPUNIT_TEST(split_st_RCU_GPI_base_cmp_lazy)
1673             CPPUNIT_TEST(split_st_RCU_GPI_base_less_lazy)
1674             CPPUNIT_TEST(split_st_RCU_GPI_base_cmpmix_lazy)
1675             CPPUNIT_TEST(split_st_RCU_GPI_member_cmp_lazy)
1676             CPPUNIT_TEST(split_st_RCU_GPI_member_less_lazy)
1677             CPPUNIT_TEST(split_st_RCU_GPI_member_cmpmix_lazy)
1678
1679             CPPUNIT_TEST(split_dyn_RCU_GPB_base_cmp_lazy)
1680             CPPUNIT_TEST(split_dyn_RCU_GPB_base_less_lazy)
1681             CPPUNIT_TEST(split_dyn_RCU_GPB_base_cmpmix_lazy)
1682             CPPUNIT_TEST(split_dyn_RCU_GPB_member_cmp_lazy)
1683             CPPUNIT_TEST(split_dyn_RCU_GPB_member_less_lazy)
1684             CPPUNIT_TEST(split_dyn_RCU_GPB_member_cmpmix_lazy)
1685             CPPUNIT_TEST(split_st_RCU_GPB_base_cmp_lazy)
1686             CPPUNIT_TEST(split_st_RCU_GPB_base_less_lazy)
1687             CPPUNIT_TEST(split_st_RCU_GPB_base_cmpmix_lazy)
1688             CPPUNIT_TEST(split_st_RCU_GPB_member_cmp_lazy)
1689             CPPUNIT_TEST(split_st_RCU_GPB_member_less_lazy)
1690             CPPUNIT_TEST(split_st_RCU_GPB_member_cmpmix_lazy)
1691
1692             CPPUNIT_TEST(split_dyn_RCU_GPT_base_cmp_lazy)
1693             CPPUNIT_TEST(split_dyn_RCU_GPT_base_less_lazy)
1694             CPPUNIT_TEST(split_dyn_RCU_GPT_base_cmpmix_lazy)
1695             CPPUNIT_TEST(split_dyn_RCU_GPT_member_cmp_lazy)
1696             CPPUNIT_TEST(split_dyn_RCU_GPT_member_less_lazy)
1697             CPPUNIT_TEST(split_dyn_RCU_GPT_member_cmpmix_lazy)
1698             CPPUNIT_TEST(split_st_RCU_GPT_base_cmp_lazy)
1699             CPPUNIT_TEST(split_st_RCU_GPT_base_less_lazy)
1700             CPPUNIT_TEST(split_st_RCU_GPT_base_cmpmix_lazy)
1701             CPPUNIT_TEST(split_st_RCU_GPT_member_cmp_lazy)
1702             CPPUNIT_TEST(split_st_RCU_GPT_member_less_lazy)
1703             CPPUNIT_TEST(split_st_RCU_GPT_member_cmpmix_lazy)
1704
1705             CPPUNIT_TEST(split_dyn_RCU_SHB_base_cmp_lazy)
1706             CPPUNIT_TEST(split_dyn_RCU_SHB_base_less_lazy)
1707             CPPUNIT_TEST(split_dyn_RCU_SHB_base_cmpmix_lazy)
1708             CPPUNIT_TEST(split_dyn_RCU_SHB_member_cmp_lazy)
1709             CPPUNIT_TEST(split_dyn_RCU_SHB_member_less_lazy)
1710             CPPUNIT_TEST(split_dyn_RCU_SHB_member_cmpmix_lazy)
1711             CPPUNIT_TEST(split_st_RCU_SHB_base_cmp_lazy)
1712             CPPUNIT_TEST(split_st_RCU_SHB_base_less_lazy)
1713             CPPUNIT_TEST(split_st_RCU_SHB_base_cmpmix_lazy)
1714             CPPUNIT_TEST(split_st_RCU_SHB_member_cmp_lazy)
1715             CPPUNIT_TEST(split_st_RCU_SHB_member_less_lazy)
1716             CPPUNIT_TEST(split_st_RCU_SHB_member_cmpmix_lazy)
1717
1718             CPPUNIT_TEST(split_dyn_RCU_SHT_base_cmp_lazy)
1719             CPPUNIT_TEST(split_dyn_RCU_SHT_base_less_lazy)
1720             CPPUNIT_TEST(split_dyn_RCU_SHT_base_cmpmix_lazy)
1721             CPPUNIT_TEST(split_dyn_RCU_SHT_member_cmp_lazy)
1722             CPPUNIT_TEST(split_dyn_RCU_SHT_member_less_lazy)
1723             CPPUNIT_TEST(split_dyn_RCU_SHT_member_cmpmix_lazy)
1724             CPPUNIT_TEST(split_st_RCU_SHT_base_cmp_lazy)
1725             CPPUNIT_TEST(split_st_RCU_SHT_base_less_lazy)
1726             CPPUNIT_TEST(split_st_RCU_SHT_base_cmpmix_lazy)
1727             CPPUNIT_TEST(split_st_RCU_SHT_member_cmp_lazy)
1728             CPPUNIT_TEST(split_st_RCU_SHT_member_less_lazy)
1729             CPPUNIT_TEST(split_st_RCU_SHT_member_cmpmix_lazy)
1730
1731             CPPUNIT_TEST(split_dyn_nogc_base_cmp_lazy)
1732             CPPUNIT_TEST(split_dyn_nogc_base_less_lazy)
1733             CPPUNIT_TEST(split_dyn_nogc_base_cmpmix_lazy)
1734             CPPUNIT_TEST(split_dyn_nogc_member_cmp_lazy)
1735             CPPUNIT_TEST(split_dyn_nogc_member_less_lazy)
1736             CPPUNIT_TEST(split_dyn_nogc_member_cmpmix_lazy)
1737             CPPUNIT_TEST(split_st_nogc_base_cmp_lazy)
1738             CPPUNIT_TEST(split_st_nogc_base_less_lazy)
1739             CPPUNIT_TEST(split_st_nogc_base_cmpmix_lazy)
1740             CPPUNIT_TEST(split_st_nogc_member_cmp_lazy)
1741             CPPUNIT_TEST(split_st_nogc_member_less_lazy)
1742             CPPUNIT_TEST(split_st_nogc_member_cmpmix_lazy)
1743
1744         CPPUNIT_TEST_SUITE_END()
1745
1746     };
1747
1748 }   // namespace set