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                     gp = s.get( nKey );
 507                     CPPUNIT_ASSERT( gp );
 508                     CPPUNIT_ASSERT( !gp.empty());
 509                     CPPUNIT_CHECK( gp->nKey == nKey );
 510                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 511                     gp.release();
 512
 513                     gp = s.extract( nKey );
 514                     CPPUNIT_ASSERT( gp );
 515                     CPPUNIT_ASSERT( !gp.empty() );
 516                     CPPUNIT_CHECK( gp->nKey == nKey );
 517                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 518                     gp.release();
 519
 520                     gp = s.get( nKey );
 521                     CPPUNIT_CHECK( !gp );
 522                     CPPUNIT_ASSERT( gp.empty() );
 523                     CPPUNIT_CHECK( !s.extract( nKey ));
 524                     CPPUNIT_CHECK( gp.empty() );
 525
 526                     nKey = arr[i+1];
 527                     gp = s.get_with( nKey, less<value_type>() );
 528                     CPPUNIT_ASSERT( gp );
 529                     CPPUNIT_CHECK( gp->nKey == nKey );
 530                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 531                     gp.release();
 532
 533                     gp = s.extract_with( nKey, less<value_type>() );
 534                     CPPUNIT_ASSERT( gp );
 535                     CPPUNIT_ASSERT( !gp.empty() );
 536                     CPPUNIT_CHECK( gp->nKey == nKey );
 537                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 538                     gp.release();
 539
 540                     gp = s.get_with( nKey, less<value_type>() );
 541                     CPPUNIT_CHECK( !gp );
 542                     CPPUNIT_CHECK( gp.empty());
 543                     CPPUNIT_CHECK( !s.extract_with( nKey, less<value_type>() ));
 544                     CPPUNIT_CHECK( gp.empty());
 545                 }
 546                 CPPUNIT_CHECK( s.empty() );
 547                 CPPUNIT_CHECK( check_size( s, 0 ));
 548
 549                 CPPUNIT_CHECK( !s.get( 100 ));
 550                 CPPUNIT_CHECK( !s.extract( 100 ));
 551                 CPPUNIT_CHECK( gp.empty() );
 552
 553                 Set::gc::force_dispose();
 554             }
 555         }
 556
 557         template <class Set>
 558         void test_iter()
 559         {
 560             typedef typename Set::value_type    value_type;
 561             typedef typename Set::iterator set_iterator;
 562             typedef typename Set::iterator const_set_iterator;
 563
 564             value_type  v[500];
 565             {
 566                 Set s( 100, 4 );
 567
 568                 for ( int i = 0; unsigned(i) < sizeof(v)/sizeof(v[0]); ++i ) {
 569                     v[i].nKey = i;
 570                     v[i].nVal = i * 2;
 571
 572                     CPPUNIT_ASSERT( s.insert( v[i] ));
 573                 }
 574
 575                 {
 576                     typename Set::iterator it( s.begin() );
 577                     typename Set::const_iterator cit( s.cbegin() );
 578                     CPPUNIT_CHECK( it == cit );
 579                     CPPUNIT_CHECK( it != s.end() );
 580                     CPPUNIT_CHECK( it != s.cend() );
 581                     CPPUNIT_CHECK( cit != s.end() );
 582                     CPPUNIT_CHECK( cit != s.cend() );
 583                     ++it;
 584                     CPPUNIT_CHECK( it != cit );
 585                     CPPUNIT_CHECK( it != s.end() );
 586                     CPPUNIT_CHECK( it != s.cend() );
 587                     CPPUNIT_CHECK( cit != s.end() );
 588                     CPPUNIT_CHECK( cit != s.cend() );
 589                     ++cit;
 590                     CPPUNIT_CHECK( it == cit );
 591                     CPPUNIT_CHECK( it != s.end() );
 592                     CPPUNIT_CHECK( it != s.cend() );
 593                     CPPUNIT_CHECK( cit != s.end() );
 594                     CPPUNIT_CHECK( cit != s.cend() );
 595                 }
 596
 597                 int nCount = 0;
 598                 for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
 599                     set_iterator it2 = it;
 600                     CPPUNIT_CHECK( it == it2 );
 601                     CPPUNIT_CHECK( it2 != itEnd );
 602                     CPPUNIT_ASSERT( (*it).nKey * 2 == it->nVal );
 603                     it->nVal = (*it).nKey;
 604                     ++nCount;
 605                 }
 606                 CPPUNIT_ASSERT( nCount == sizeof(v)/sizeof(v[0]));
 607
 608                 nCount = 0;
 609                 for ( const_set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
 610                     CPPUNIT_ASSERT( (*it).nKey == it->nVal );
 611                     ++nCount;
 612                 }
 613                 CPPUNIT_ASSERT( nCount == sizeof(v)/sizeof(v[0]));
 614
 615                 for ( size_t i = 0; i < sizeof(v)/sizeof(v[0]); ++i ) {
 616                     CPPUNIT_ASSERT( v[i].nKey == v[i].nVal );
 617                 }
 618             }
 619
 620             Set::gc::force_dispose();
 621
 622             for ( size_t i = 0; i < sizeof(v)/sizeof(v[0]); ++i ) {
 623                 CPPUNIT_ASSERT( v[i].nDisposeCount == 1 );
 624             }
 625         }
 626
 627         template <class Set>
 628         void test_int_nogc()
 629         {
 630             typedef typename Set::value_type    value_type;
 631
 632             value_type v1( 10, 50 );
 633             value_type v2( 5, 25  );
 634             value_type v3( 20, 100 );
 635             int key;
 636
 637             {
 638                 {
 639                     Set s( 64, 4 );
 640
 641                     // insert test
 642                     CPPUNIT_ASSERT( s.empty() );
 643                     CPPUNIT_ASSERT( check_size( s, 0 ));
 644
 645                     // insert/find test
 646                     CPPUNIT_ASSERT( s.find( v1.key() ) == nullptr );
 647                     CPPUNIT_ASSERT( s.insert( v1 ));
 648                     CPPUNIT_ASSERT( s.find_with( v1.key(), less<value_type>() ) == &v1 );
 649                     CPPUNIT_ASSERT( check_size( s, 1 ));
 650                     CPPUNIT_ASSERT( !s.empty() );
 651
 652                     CPPUNIT_ASSERT( s.find( v2.key() ) == nullptr );
 653                     CPPUNIT_ASSERT( s.insert( v2 ));
 654                     CPPUNIT_ASSERT( v2.nFindCount == 0 );
 655                     CPPUNIT_ASSERT( s.find( key = v2.key(), find_functor() ));
 656                     CPPUNIT_ASSERT( v2.nFindCount == 1 );
 657                     v2.nFindCount = 0;
 658                     CPPUNIT_ASSERT( check_size( s, 2 ));
 659                     CPPUNIT_ASSERT( !s.empty() );
 660
 661                     {
 662                         find_functor    ff;
 663                         CPPUNIT_ASSERT( s.find( v3 ) == nullptr );
 664                         CPPUNIT_ASSERT( s.insert( v3 ));
 665                         CPPUNIT_ASSERT( v3.nFindCount == 0 );
 666                         CPPUNIT_ASSERT( s.find_with( v3, less<value_type>(), std::ref(ff) ));
 667                         CPPUNIT_ASSERT( v3.nFindCount == 1 );
 668                         v3.nFindCount = 0;
 669                         CPPUNIT_ASSERT( check_size( s, 3 ));
 670                         CPPUNIT_ASSERT( !s.empty() );
 671                     }
 672                 }
 673
 674                 // s.clear()   ; // not all set supports clear() method
 675                 CPPUNIT_ASSERT( v1.nDisposeCount == 1 );
 676                 CPPUNIT_ASSERT( v2.nDisposeCount == 1 );
 677                 CPPUNIT_ASSERT( v3.nDisposeCount == 1 );
 678
 679
 680                 // ensure test
 681                 {
 682                     Set s( 64, 4 );
 683
 684                     ensure_functor f;
 685                     std::pair<bool, bool> ret = s.ensure( v1, f );
 686                     CPPUNIT_ASSERT( ret.first );
 687                     CPPUNIT_ASSERT( ret.second );
 688                     CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 689                     CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
 690                     CPPUNIT_ASSERT( check_size( s, 1 ));
 691
 692                     ret = s.ensure( v2, f );
 693                     CPPUNIT_ASSERT( ret.first );
 694                     CPPUNIT_ASSERT( ret.second );
 695                     CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 696                     CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
 697                     CPPUNIT_ASSERT( check_size( s, 2 ));
 698
 699                     ret = s.ensure( v3, f );
 700                     CPPUNIT_ASSERT( ret.first );
 701                     CPPUNIT_ASSERT( ret.second );
 702                     CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 703                     CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
 704                     CPPUNIT_ASSERT( check_size( s, 3 ));
 705
 706                     CPPUNIT_ASSERT( s.find( v1 ) == &v1 );
 707                     CPPUNIT_ASSERT( s.find( v2 ) == &v2 );
 708                     CPPUNIT_ASSERT( s.find( v3 ) == &v3 );
 709
 710                     ret = s.ensure( v1, f );
 711                     CPPUNIT_ASSERT( ret.first );
 712                     CPPUNIT_ASSERT( !ret.second );
 713                     CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 714                     CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
 715                     CPPUNIT_ASSERT( check_size( s, 3 ));
 716
 717                     ret = s.ensure( v2, f );
 718                     CPPUNIT_ASSERT( ret.first );
 719                     CPPUNIT_ASSERT( !ret.second );
 720                     CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 721                     CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
 722                     CPPUNIT_ASSERT( check_size( s, 3 ));
 723
 724                     ret = s.ensure( v3, f );
 725                     CPPUNIT_ASSERT( ret.first );
 726                     CPPUNIT_ASSERT( !ret.second );
 727                     CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 728                     CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
 729                     CPPUNIT_ASSERT( check_size( s, 3 ));
 730
 731                     CPPUNIT_ASSERT( s.find( v1 ) == &v1 );
 732                     CPPUNIT_ASSERT( s.find( v2 ) == &v2 );
 733                     CPPUNIT_ASSERT( s.find( v3 ) == &v3 );
 734                 }
 735             }
 736
 737             // dispose on destruct test
 738             CPPUNIT_ASSERT( v1.nDisposeCount == 2 );
 739             CPPUNIT_ASSERT( v2.nDisposeCount == 2 );
 740             CPPUNIT_ASSERT( v3.nDisposeCount == 2 );
 741
 742             // Iterator test
 743             test_iter<Set>();
 744         }
 745
 746
 747 #define ASSERT_RCU_FIND( _expr ) { rcu_lock rl; CPPUNIT_ASSERT( _expr ); }
 748         template <class Set>
 749         void test_rcu_int_with( Set& s )
 750         {
 751             typedef typename Set::value_type    value_type;
 752             typedef typename Set::gc::scoped_lock rcu_lock;
 753
 754             value_type v1( 10, 50 );
 755             value_type v2( 5, 25  );
 756             value_type v3( 20, 100 );
 757             value_type v4( 40, 400 );
 758             int key;
 759
 760             CPPUNIT_ASSERT( s.empty() );
 761             CPPUNIT_ASSERT( check_size( s, 0 ));
 762
 763             // insert/find test
 764
 765             ASSERT_RCU_FIND( !s.find_with( v1.key(), less<value_type>() ));
 766             CPPUNIT_ASSERT( s.insert( v1 ));
 767             ASSERT_RCU_FIND( s.find_with( v1.key(), less<value_type>()) );
 768             CPPUNIT_ASSERT( check_size( s, 1 ));
 769             CPPUNIT_ASSERT( !s.empty() );
 770
 771             ASSERT_RCU_FIND( !s.find( v2.key() ));
 772             CPPUNIT_ASSERT( s.insert( v2 ));
 773             CPPUNIT_ASSERT( v2.nFindCount == 0 );
 774             CPPUNIT_ASSERT( s.find( key = v2.key(), find_functor() ));
 775             CPPUNIT_ASSERT( v2.nFindCount == 1 );
 776             v2.nFindCount = 0;
 777             CPPUNIT_ASSERT( check_size( s, 2 ));
 778             CPPUNIT_ASSERT( !s.empty() );
 779
 780             {
 781                 insert_functor  fi;
 782                 find_functor    ff;
 783                 ASSERT_RCU_FIND( !s.find( v3 ));
 784                 CPPUNIT_ASSERT( v3.nVal != v3.nKey * 100 );
 785                 CPPUNIT_ASSERT( s.insert( v3, std::ref(fi) ));
 786                 CPPUNIT_ASSERT( v3.nVal == v3.nKey * 100 );
 787                 CPPUNIT_ASSERT( v3.nFindCount == 0 );
 788                 CPPUNIT_ASSERT( s.find_with( v3, less<value_type>(), std::ref(ff) ));
 789                 CPPUNIT_ASSERT( v3.nFindCount == 1 );
 790                 v3.nFindCount = 0;
 791                 CPPUNIT_ASSERT( check_size( s, 3 ));
 792                 CPPUNIT_ASSERT( !s.empty() );
 793             }
 794
 795             // unlink test
 796             CPPUNIT_ASSERT( s.unlink( v1 ));
 797             ASSERT_RCU_FIND( !s.find( v1 ));
 798             ASSERT_RCU_FIND( s.find( v2 ));
 799             ASSERT_RCU_FIND( s.find( v3 ));
 800             CPPUNIT_ASSERT( check_size( s, 2 ));
 801
 802             CPPUNIT_ASSERT( !s.unlink( v1 ));
 803             ASSERT_RCU_FIND( !s.find( v1 ));
 804             CPPUNIT_ASSERT( check_size( s, 2 ));
 805
 806             ASSERT_RCU_FIND( s.find( v3 ) );
 807             CPPUNIT_ASSERT( s.unlink( v3 ));
 808             ASSERT_RCU_FIND( !s.find( v3 ));
 809             CPPUNIT_ASSERT( check_size( s, 1 ));
 810
 811             ASSERT_RCU_FIND( s.find( v2 ));
 812             CPPUNIT_ASSERT( s.unlink( v2 ));
 813             ASSERT_RCU_FIND( !s.find( v1 ));
 814             ASSERT_RCU_FIND( !s.find( v2 ));
 815             ASSERT_RCU_FIND( !s.find( v3 ));
 816             CPPUNIT_ASSERT( check_size( s, 0 ));
 817             CPPUNIT_ASSERT( s.empty() );
 818
 819             Set::gc::force_dispose();
 820             // unlink function calls disposer
 821             CPPUNIT_ASSERT( v1.nDisposeCount == 1 );
 822             CPPUNIT_ASSERT( v2.nDisposeCount == 1 );
 823             CPPUNIT_ASSERT( v3.nDisposeCount == 1 );
 824
 825             // ensure test
 826             {
 827                 ensure_functor f;
 828                 std::pair<bool, bool> ret = s.ensure( v1, f );
 829                 CPPUNIT_ASSERT( ret.first );
 830                 CPPUNIT_ASSERT( ret.second );
 831                 CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 832                 CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
 833                 CPPUNIT_ASSERT( check_size( s, 1 ));
 834
 835                 ret = s.ensure( v2, f );
 836                 CPPUNIT_ASSERT( ret.first );
 837                 CPPUNIT_ASSERT( ret.second );
 838                 CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 839                 CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
 840                 CPPUNIT_ASSERT( check_size( s, 2 ));
 841
 842                 ret = s.ensure( v3, f );
 843                 CPPUNIT_ASSERT( ret.first );
 844                 CPPUNIT_ASSERT( ret.second );
 845                 CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 846                 CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
 847                 CPPUNIT_ASSERT( check_size( s, 3 ));
 848
 849                 ASSERT_RCU_FIND( s.find( v1 ));
 850                 ASSERT_RCU_FIND( s.find( v2 ));
 851                 ASSERT_RCU_FIND( s.find( v3 ));
 852
 853                 ret = s.ensure( v1, f );
 854                 CPPUNIT_ASSERT( ret.first );
 855                 CPPUNIT_ASSERT( !ret.second );
 856                 CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
 857                 CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
 858                 CPPUNIT_ASSERT( check_size( s, 3 ));
 859
 860                 ret = s.ensure( v2, f );
 861                 CPPUNIT_ASSERT( ret.first );
 862                 CPPUNIT_ASSERT( !ret.second );
 863                 CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
 864                 CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
 865                 CPPUNIT_ASSERT( check_size( s, 3 ));
 866
 867                 ret = s.ensure( v3, f );
 868                 CPPUNIT_ASSERT( ret.first );
 869                 CPPUNIT_ASSERT( !ret.second );
 870                 CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
 871                 CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
 872                 CPPUNIT_ASSERT( check_size( s, 3 ));
 873
 874                 ASSERT_RCU_FIND( s.find( v1 ) );
 875                 ASSERT_RCU_FIND( s.find( v2 ));
 876                 ASSERT_RCU_FIND( s.find( v3 ));
 877             }
 878
 879             // erase test
 880             ASSERT_RCU_FIND( s.find( v1 ));
 881             ASSERT_RCU_FIND( s.find_with( v2, less<value_type>() ));
 882             ASSERT_RCU_FIND( s.find( v3 ));
 883             CPPUNIT_ASSERT( check_size( s, 3 ));
 884             CPPUNIT_ASSERT( !s.empty() );
 885
 886             CPPUNIT_ASSERT( v1.nEraseCount == 0 );
 887             CPPUNIT_ASSERT( s.erase_with( v1, less<value_type>(), erase_functor() ));
 888             CPPUNIT_ASSERT( v1.nEraseCount == 1 );
 889             ASSERT_RCU_FIND( !s.find( v1 ));
 890             ASSERT_RCU_FIND( s.find( v2 ) );
 891             ASSERT_RCU_FIND( s.find( v3 ) );
 892             CPPUNIT_ASSERT( check_size( s, 2 ));
 893             CPPUNIT_ASSERT( !s.empty() );
 894
 895             CPPUNIT_ASSERT( !s.erase( v1 ));
 896             ASSERT_RCU_FIND( !s.find( v1 ));
 897             ASSERT_RCU_FIND( s.find( v2 ));
 898             ASSERT_RCU_FIND( s.find( v3 ) );
 899             CPPUNIT_ASSERT( check_size( s, 2 ));
 900             CPPUNIT_ASSERT( !s.empty() );
 901
 902             ASSERT_RCU_FIND( !s.find( v4 ));
 903             CPPUNIT_ASSERT( s.insert(v4));
 904             ASSERT_RCU_FIND( s.find( v4.key() ));
 905             CPPUNIT_ASSERT( s.erase_with( v4.key(), less<value_type>() ));
 906             ASSERT_RCU_FIND( !s.find( v4.key() ));
 907
 908             CPPUNIT_ASSERT( s.erase( v2.key() ));
 909             ASSERT_RCU_FIND( !s.find( v1 ));
 910             ASSERT_RCU_FIND( !s.find( v2 ));
 911             ASSERT_RCU_FIND( s.find( v3 ) );
 912             CPPUNIT_ASSERT( check_size( s, 1 ));
 913             CPPUNIT_ASSERT( !s.empty() );
 914
 915             CPPUNIT_ASSERT( !s.erase( v2.key() ));
 916             ASSERT_RCU_FIND( !s.find( v1 ));
 917             ASSERT_RCU_FIND( !s.find( v2 ));
 918             ASSERT_RCU_FIND( s.find( v3 ) );
 919             CPPUNIT_ASSERT( check_size( s, 1 ));
 920             CPPUNIT_ASSERT( !s.empty() );
 921
 922             CPPUNIT_ASSERT( v3.nEraseCount == 0 );
 923             CPPUNIT_ASSERT( s.erase( v3, erase_functor() ));
 924             CPPUNIT_ASSERT( v3.nEraseCount == 1 );
 925             ASSERT_RCU_FIND( !s.find( v1 ));
 926             ASSERT_RCU_FIND( !s.find( v2 ));
 927             ASSERT_RCU_FIND( !s.find( v3 ));
 928             CPPUNIT_ASSERT( check_size( s, 0 ));
 929             CPPUNIT_ASSERT( s.empty() );
 930
 931             // dispose test
 932             Set::gc::force_dispose();
 933             CPPUNIT_ASSERT( v1.nDisposeCount == 2 );
 934             CPPUNIT_ASSERT( v2.nDisposeCount == 2 );
 935             CPPUNIT_ASSERT( v3.nDisposeCount == 2 );
 936             CPPUNIT_ASSERT( v4.nDisposeCount == 1 );
 937
 938             CPPUNIT_ASSERT( s.empty() );
 939             CPPUNIT_ASSERT( s.insert( v1 ));
 940             CPPUNIT_ASSERT( s.insert( v3 ));
 941             CPPUNIT_ASSERT( check_size( s, 2 ));
 942             CPPUNIT_ASSERT( !s.empty() );
 943
 944             {
 945                 value_type v( v1 );
 946                 CPPUNIT_ASSERT( !s.unlink( v ) );
 947             }
 948
 949             CPPUNIT_ASSERT( s.unlink( v3 ) );
 950             ASSERT_RCU_FIND( s.find( v1 ));
 951             ASSERT_RCU_FIND( !s.find( v2 ));
 952             ASSERT_RCU_FIND( !s.find( v3 ));
 953             CPPUNIT_ASSERT( check_size( s, 1 ));
 954             CPPUNIT_ASSERT( !s.empty() );
 955
 956             CPPUNIT_ASSERT( !s.unlink( v3 ));
 957             ASSERT_RCU_FIND( s.find( v1 ));
 958             ASSERT_RCU_FIND( !s.find( v2 ));
 959             ASSERT_RCU_FIND( !s.find( v3 ));
 960             CPPUNIT_ASSERT( check_size( s, 1 ));
 961             CPPUNIT_ASSERT( !s.empty() );
 962
 963             CPPUNIT_ASSERT( s.unlink( v1 ));
 964             ASSERT_RCU_FIND( !s.find( v1 ));
 965             ASSERT_RCU_FIND( !s.find( v2 ));
 966             ASSERT_RCU_FIND( !s.find( v3 ));
 967             CPPUNIT_ASSERT( check_size( s, 0 ));
 968             CPPUNIT_ASSERT( s.empty() );
 969
 970             CPPUNIT_ASSERT( !s.unlink( v2 ));
 971             ASSERT_RCU_FIND( !s.find( v1 ));
 972             ASSERT_RCU_FIND( !s.find( v2 ));
 973             ASSERT_RCU_FIND( !s.find( v3 ));
 974             CPPUNIT_ASSERT( check_size( s, 0 ));
 975             CPPUNIT_ASSERT( s.empty() );
 976
 977             Set::gc::force_dispose();
 978             CPPUNIT_ASSERT( v1.nDisposeCount == 3 );
 979             CPPUNIT_ASSERT( v2.nDisposeCount == 2 );
 980             CPPUNIT_ASSERT( v3.nDisposeCount == 3 );
 981             CPPUNIT_ASSERT( v4.nDisposeCount == 1 );
 982
 983             // clear test
 984             CPPUNIT_ASSERT( s.insert( v1 ));
 985             CPPUNIT_ASSERT( s.insert( v3 ));
 986             CPPUNIT_ASSERT( s.insert( v2 ));
 987
 988             s.clear();
 989             Set::gc::force_dispose();
 990             CPPUNIT_ASSERT( v1.nDisposeCount == 4 );
 991             CPPUNIT_ASSERT( v2.nDisposeCount == 3 );
 992             CPPUNIT_ASSERT( v3.nDisposeCount == 4 );
 993             CPPUNIT_ASSERT( v4.nDisposeCount == 1 );
 994         }
 995 #undef ASSERT_RCU_FIND
 996
 997         template <class Set>
 998         void test_rcu_int()
 999         {
1000             {
1001                 Set s( 64, 4 );
1002                 test_rcu_int_with( s );
1003             }
1004
1005             // Iterator test
1006             test_iter<Set>();
1007
1008             // Extract tests
1009             typedef typename Set::gc    rcu;
1010             typedef typename Set::value_type    value_type;
1011             typedef typename Set::rcu_lock      rcu_lock;
1012
1013             typename Set::exempt_ptr ep;
1014
1015             {
1016                 static size_t const nLimit = 1024;
1017                 value_type arrItems[nLimit];
1018                 int arr[nLimit];
1019                 for ( size_t i = 0; i < nLimit; ++i )
1020                     arr[i] = (int) i;
1021                 std::random_shuffle( arr, arr + nLimit );
1022
1023                 for ( size_t i = 0; i < nLimit; ++i ) {
1024                     arrItems[i].nKey = arr[i];
1025                     arrItems[i].nVal = arr[i] * 2;
1026                 }
1027
1028                 Set s( nLimit, 2 );
1029                 for ( size_t i = 0; i < nLimit; ++i )
1030                     CPPUNIT_ASSERT( s.insert( arrItems[i] ));
1031
1032                 for ( size_t i = 0; i < nLimit; i += 2 ) {
1033                     value_type * pVal;
1034                     int nKey = arr[i];
1035                     {
1036                         rcu_lock l;
1037                         pVal = s.get( nKey );
1038                         CPPUNIT_ASSERT( pVal != nullptr );
1039                         CPPUNIT_CHECK( pVal->nKey == nKey );
1040                         CPPUNIT_CHECK( pVal->nVal == nKey * 2 );
1041
1042                         ep = s.extract( nKey );
1043                         CPPUNIT_ASSERT( ep );
1044                         CPPUNIT_ASSERT( !ep.empty() );
1045                         CPPUNIT_CHECK( pVal->nKey == ep->nKey );
1046                         CPPUNIT_CHECK( pVal->nVal == (*ep).nVal );
1047                     }
1048                     ep.release();
1049                     {
1050                         rcu_lock l;
1051                         CPPUNIT_CHECK( s.get( nKey ) == nullptr );
1052                         CPPUNIT_CHECK( !s.extract( nKey ));
1053                         CPPUNIT_CHECK( ep.empty() );
1054
1055                         nKey = arr[i+1];
1056                         pVal = s.get_with( nKey, less<value_type>() );
1057                         CPPUNIT_ASSERT( pVal != nullptr );
1058                         CPPUNIT_CHECK( pVal->nKey == nKey );
1059                         CPPUNIT_CHECK( pVal->nVal == nKey * 2 );
1060
1061                         ep = s.extract_with( nKey, less<value_type>() );
1062                         CPPUNIT_ASSERT( ep );
1063                         CPPUNIT_ASSERT( !ep.empty() );
1064                         CPPUNIT_CHECK( pVal->nKey == ep->nKey );
1065                         CPPUNIT_CHECK( pVal->nVal == (*ep).nVal );
1066                     }
1067                     ep.release();
1068                     {
1069                         rcu_lock l;
1070                         CPPUNIT_CHECK( s.get_with( nKey, less<value_type>() ) == nullptr );
1071                         ep = s.extract_with( nKey, less<value_type>() );
1072                         CPPUNIT_CHECK( !ep );
1073                         CPPUNIT_CHECK( ep.empty() );
1074                     }
1075                 }
1076                 CPPUNIT_CHECK( s.empty() );
1077                 CPPUNIT_CHECK( check_size( s, 0 ));
1078                 {
1079                     rcu_lock l;
1080                     CPPUNIT_CHECK( s.get( 100 ) == nullptr );
1081                     ep = s.extract( 100 );
1082                     CPPUNIT_CHECK( !ep );
1083                     CPPUNIT_CHECK( ep.empty() );
1084                 }
1085
1086                 Set::gc::force_dispose();
1087             }
1088         }
1089
1090         // MichaelHashSet + MichaelList
1091         void HP_base_cmp();
1092         void HP_base_less();
1093         void HP_base_cmpmix();
1094         void HP_member_cmp();
1095         void HP_member_less();
1096         void HP_member_cmpmix();
1097
1098         void DHP_base_cmp();
1099         void DHP_base_less();
1100         void DHP_base_cmpmix();
1101         void DHP_member_cmp();
1102         void DHP_member_less();
1103         void DHP_member_cmpmix();
1104
1105         void RCU_GPI_base_cmp();
1106         void RCU_GPI_base_less();
1107         void RCU_GPI_base_cmpmix();
1108         void RCU_GPI_member_cmp();
1109         void RCU_GPI_member_less();
1110         void RCU_GPI_member_cmpmix();
1111
1112         void RCU_GPB_base_cmp();
1113         void RCU_GPB_base_less();
1114         void RCU_GPB_base_cmpmix();
1115         void RCU_GPB_member_cmp();
1116         void RCU_GPB_member_less();
1117         void RCU_GPB_member_cmpmix();
1118
1119         void RCU_GPT_base_cmp();
1120         void RCU_GPT_base_less();
1121         void RCU_GPT_base_cmpmix();
1122         void RCU_GPT_member_cmp();
1123         void RCU_GPT_member_less();
1124         void RCU_GPT_member_cmpmix();
1125
1126         void RCU_SHB_base_cmp();
1127         void RCU_SHB_base_less();
1128         void RCU_SHB_base_cmpmix();
1129         void RCU_SHB_member_cmp();
1130         void RCU_SHB_member_less();
1131         void RCU_SHB_member_cmpmix();
1132
1133         void RCU_SHT_base_cmp();
1134         void RCU_SHT_base_less();
1135         void RCU_SHT_base_cmpmix();
1136         void RCU_SHT_member_cmp();
1137         void RCU_SHT_member_less();
1138         void RCU_SHT_member_cmpmix();
1139
1140         void nogc_base_cmp();
1141         void nogc_base_less();
1142         void nogc_base_cmpmix();
1143         void nogc_member_cmp();
1144         void nogc_member_less();
1145         void nogc_member_cmpmix();
1146
1147         // MichaelHashSet + LazyList
1148         void HP_base_cmp_lazy();
1149         void HP_base_less_lazy();
1150         void HP_base_cmpmix_lazy();
1151         void HP_member_cmp_lazy();
1152         void HP_member_less_lazy();
1153         void HP_member_cmpmix_lazy();
1154
1155         void DHP_base_cmp_lazy();
1156         void DHP_base_less_lazy();
1157         void DHP_base_cmpmix_lazy();
1158         void DHP_member_cmp_lazy();
1159         void DHP_member_less_lazy();
1160         void DHP_member_cmpmix_lazy();
1161
1162         void RCU_GPI_base_cmp_lazy();
1163         void RCU_GPI_base_less_lazy();
1164         void RCU_GPI_base_cmpmix_lazy();
1165         void RCU_GPI_member_cmp_lazy();
1166         void RCU_GPI_member_less_lazy();
1167         void RCU_GPI_member_cmpmix_lazy();
1168
1169         void RCU_GPB_base_cmp_lazy();
1170         void RCU_GPB_base_less_lazy();
1171         void RCU_GPB_base_cmpmix_lazy();
1172         void RCU_GPB_member_cmp_lazy();
1173         void RCU_GPB_member_less_lazy();
1174         void RCU_GPB_member_cmpmix_lazy();
1175
1176         void RCU_GPT_base_cmp_lazy();
1177         void RCU_GPT_base_less_lazy();
1178         void RCU_GPT_base_cmpmix_lazy();
1179         void RCU_GPT_member_cmp_lazy();
1180         void RCU_GPT_member_less_lazy();
1181         void RCU_GPT_member_cmpmix_lazy();
1182
1183         void RCU_SHB_base_cmp_lazy();
1184         void RCU_SHB_base_less_lazy();
1185         void RCU_SHB_base_cmpmix_lazy();
1186         void RCU_SHB_member_cmp_lazy();
1187         void RCU_SHB_member_less_lazy();
1188         void RCU_SHB_member_cmpmix_lazy();
1189
1190         void RCU_SHT_base_cmp_lazy();
1191         void RCU_SHT_base_less_lazy();
1192         void RCU_SHT_base_cmpmix_lazy();
1193         void RCU_SHT_member_cmp_lazy();
1194         void RCU_SHT_member_less_lazy();
1195         void RCU_SHT_member_cmpmix_lazy();
1196
1197         void nogc_base_cmp_lazy();
1198         void nogc_base_less_lazy();
1199         void nogc_base_cmpmix_lazy();
1200         void nogc_member_cmp_lazy();
1201         void nogc_member_less_lazy();
1202         void nogc_member_cmpmix_lazy();
1203
1204         // SplitListSet + MichaelList [dyn - dynamic bucket table, st - static bucket table]
1205         void split_dyn_HP_base_cmp();
1206         void split_dyn_HP_base_less();
1207         void split_dyn_HP_base_cmpmix();
1208         void split_dyn_HP_base_cmpmix_stat();
1209         void split_dyn_HP_member_cmp();
1210         void split_dyn_HP_member_less();
1211         void split_dyn_HP_member_cmpmix();
1212         void split_dyn_HP_member_cmpmix_stat();
1213         void split_st_HP_base_cmp();
1214         void split_st_HP_base_less();
1215         void split_st_HP_base_cmpmix();
1216         void split_st_HP_base_cmpmix_stat();
1217         void split_st_HP_member_cmp();
1218         void split_st_HP_member_less();
1219         void split_st_HP_member_cmpmix();
1220         void split_st_HP_member_cmpmix_stat();
1221
1222         void split_dyn_DHP_base_cmp();
1223         void split_dyn_DHP_base_less();
1224         void split_dyn_DHP_base_cmpmix();
1225         void split_dyn_DHP_base_cmpmix_stat();
1226         void split_dyn_DHP_member_cmp();
1227         void split_dyn_DHP_member_less();
1228         void split_dyn_DHP_member_cmpmix();
1229         void split_dyn_DHP_member_cmpmix_stat();
1230         void split_st_DHP_base_cmp();
1231         void split_st_DHP_base_less();
1232         void split_st_DHP_base_cmpmix();
1233         void split_st_DHP_base_cmpmix_stat();
1234         void split_st_DHP_member_cmp();
1235         void split_st_DHP_member_less();
1236         void split_st_DHP_member_cmpmix();
1237         void split_st_DHP_member_cmpmix_stat();
1238
1239         void split_dyn_RCU_GPI_base_cmp();
1240         void split_dyn_RCU_GPI_base_less();
1241         void split_dyn_RCU_GPI_base_cmpmix();
1242         void split_dyn_RCU_GPI_base_cmpmix_stat();
1243         void split_dyn_RCU_GPI_member_cmp();
1244         void split_dyn_RCU_GPI_member_less();
1245         void split_dyn_RCU_GPI_member_cmpmix();
1246         void split_dyn_RCU_GPI_member_cmpmix_stat();
1247         void split_st_RCU_GPI_base_cmp();
1248         void split_st_RCU_GPI_base_less();
1249         void split_st_RCU_GPI_base_cmpmix();
1250         void split_st_RCU_GPI_base_cmpmix_stat();
1251         void split_st_RCU_GPI_member_cmp();
1252         void split_st_RCU_GPI_member_less();
1253         void split_st_RCU_GPI_member_cmpmix();
1254         void split_st_RCU_GPI_member_cmpmix_stat();
1255
1256         void split_dyn_RCU_GPB_base_cmp();
1257         void split_dyn_RCU_GPB_base_less();
1258         void split_dyn_RCU_GPB_base_cmpmix();
1259         void split_dyn_RCU_GPB_base_cmpmix_stat();
1260         void split_dyn_RCU_GPB_member_cmp();
1261         void split_dyn_RCU_GPB_member_less();
1262         void split_dyn_RCU_GPB_member_cmpmix();
1263         void split_dyn_RCU_GPB_member_cmpmix_stat();
1264         void split_st_RCU_GPB_base_cmp();
1265         void split_st_RCU_GPB_base_less();
1266         void split_st_RCU_GPB_base_cmpmix();
1267         void split_st_RCU_GPB_base_cmpmix_stat();
1268         void split_st_RCU_GPB_member_cmp();
1269         void split_st_RCU_GPB_member_less();
1270         void split_st_RCU_GPB_member_cmpmix();
1271         void split_st_RCU_GPB_member_cmpmix_stat();
1272
1273         void split_dyn_RCU_GPT_base_cmp();
1274         void split_dyn_RCU_GPT_base_less();
1275         void split_dyn_RCU_GPT_base_cmpmix();
1276         void split_dyn_RCU_GPT_base_cmpmix_stat();
1277         void split_dyn_RCU_GPT_member_cmp();
1278         void split_dyn_RCU_GPT_member_less();
1279         void split_dyn_RCU_GPT_member_cmpmix();
1280         void split_dyn_RCU_GPT_member_cmpmix_stat();
1281         void split_st_RCU_GPT_base_cmp();
1282         void split_st_RCU_GPT_base_less();
1283         void split_st_RCU_GPT_base_cmpmix();
1284         void split_st_RCU_GPT_base_cmpmix_stat();
1285         void split_st_RCU_GPT_member_cmp();
1286         void split_st_RCU_GPT_member_less();
1287         void split_st_RCU_GPT_member_cmpmix();
1288         void split_st_RCU_GPT_member_cmpmix_stat();
1289
1290         void split_dyn_RCU_SHB_base_cmp();
1291         void split_dyn_RCU_SHB_base_less();
1292         void split_dyn_RCU_SHB_base_cmpmix();
1293         void split_dyn_RCU_SHB_base_cmpmix_stat();
1294         void split_dyn_RCU_SHB_member_cmp();
1295         void split_dyn_RCU_SHB_member_less();
1296         void split_dyn_RCU_SHB_member_cmpmix();
1297         void split_dyn_RCU_SHB_member_cmpmix_stat();
1298         void split_st_RCU_SHB_base_cmp();
1299         void split_st_RCU_SHB_base_less();
1300         void split_st_RCU_SHB_base_cmpmix();
1301         void split_st_RCU_SHB_base_cmpmix_stat();
1302         void split_st_RCU_SHB_member_cmp();
1303         void split_st_RCU_SHB_member_less();
1304         void split_st_RCU_SHB_member_cmpmix();
1305         void split_st_RCU_SHB_member_cmpmix_stat();
1306
1307         void split_dyn_RCU_SHT_base_cmp();
1308         void split_dyn_RCU_SHT_base_less();
1309         void split_dyn_RCU_SHT_base_cmpmix();
1310         void split_dyn_RCU_SHT_base_cmpmix_stat();
1311         void split_dyn_RCU_SHT_member_cmp();
1312         void split_dyn_RCU_SHT_member_less();
1313         void split_dyn_RCU_SHT_member_cmpmix();
1314         void split_dyn_RCU_SHT_member_cmpmix_stat();
1315         void split_st_RCU_SHT_base_cmp();
1316         void split_st_RCU_SHT_base_less();
1317         void split_st_RCU_SHT_base_cmpmix();
1318         void split_st_RCU_SHT_base_cmpmix_stat();
1319         void split_st_RCU_SHT_member_cmp();
1320         void split_st_RCU_SHT_member_less();
1321         void split_st_RCU_SHT_member_cmpmix();
1322         void split_st_RCU_SHT_member_cmpmix_stat();
1323
1324         void split_dyn_nogc_base_cmp();
1325         void split_dyn_nogc_base_less();
1326         void split_dyn_nogc_base_cmpmix();
1327         void split_dyn_nogc_base_cmpmix_stat();
1328         void split_dyn_nogc_member_cmp();
1329         void split_dyn_nogc_member_less();
1330         void split_dyn_nogc_member_cmpmix();
1331         void split_dyn_nogc_member_cmpmix_stat();
1332         void split_st_nogc_base_cmp();
1333         void split_st_nogc_base_less();
1334         void split_st_nogc_base_cmpmix();
1335         void split_st_nogc_base_cmpmix_stat();
1336         void split_st_nogc_member_cmp();
1337         void split_st_nogc_member_less();
1338         void split_st_nogc_member_cmpmix();
1339         void split_st_nogc_member_cmpmix_stat();
1340
1341
1342         // SplitListSet + LazyList [dyn - dynamic bucket table, st - static bucket table]
1343         void split_dyn_HP_base_cmp_lazy();
1344         void split_dyn_HP_base_less_lazy();
1345         void split_dyn_HP_base_cmpmix_lazy();
1346         void split_dyn_HP_base_cmpmix_stat_lazy();
1347         void split_dyn_HP_member_cmp_lazy();
1348         void split_dyn_HP_member_less_lazy();
1349         void split_dyn_HP_member_cmpmix_lazy();
1350         void split_dyn_HP_member_cmpmix_stat_lazy();
1351         void split_st_HP_base_cmp_lazy();
1352         void split_st_HP_base_less_lazy();
1353         void split_st_HP_base_cmpmix_lazy();
1354         void split_st_HP_base_cmpmix_stat_lazy();
1355         void split_st_HP_member_cmp_lazy();
1356         void split_st_HP_member_less_lazy();
1357         void split_st_HP_member_cmpmix_lazy();
1358         void split_st_HP_member_cmpmix_stat_lazy();
1359
1360         void split_dyn_DHP_base_cmp_lazy();
1361         void split_dyn_DHP_base_less_lazy();
1362         void split_dyn_DHP_base_cmpmix_lazy();
1363         void split_dyn_DHP_base_cmpmix_stat_lazy();
1364         void split_dyn_DHP_member_cmp_lazy();
1365         void split_dyn_DHP_member_less_lazy();
1366         void split_dyn_DHP_member_cmpmix_lazy();
1367         void split_dyn_DHP_member_cmpmix_stat_lazy();
1368         void split_st_DHP_base_cmp_lazy();
1369         void split_st_DHP_base_less_lazy();
1370         void split_st_DHP_base_cmpmix_lazy();
1371         void split_st_DHP_base_cmpmix_stat_lazy();
1372         void split_st_DHP_member_cmp_lazy();
1373         void split_st_DHP_member_less_lazy();
1374         void split_st_DHP_member_cmpmix_lazy();
1375         void split_st_DHP_member_cmpmix_stat_lazy();
1376
1377         void split_dyn_RCU_GPI_base_cmp_lazy();
1378         void split_dyn_RCU_GPI_base_less_lazy();
1379         void split_dyn_RCU_GPI_base_cmpmix_lazy();
1380         void split_dyn_RCU_GPI_base_cmpmix_stat_lazy();
1381         void split_dyn_RCU_GPI_member_cmp_lazy();
1382         void split_dyn_RCU_GPI_member_less_lazy();
1383         void split_dyn_RCU_GPI_member_cmpmix_lazy();
1384         void split_dyn_RCU_GPI_member_cmpmix_stat_lazy();
1385         void split_st_RCU_GPI_base_cmp_lazy();
1386         void split_st_RCU_GPI_base_less_lazy();
1387         void split_st_RCU_GPI_base_cmpmix_lazy();
1388         void split_st_RCU_GPI_base_cmpmix_stat_lazy();
1389         void split_st_RCU_GPI_member_cmp_lazy();
1390         void split_st_RCU_GPI_member_less_lazy();
1391         void split_st_RCU_GPI_member_cmpmix_lazy();
1392         void split_st_RCU_GPI_member_cmpmix_stat_lazy();
1393
1394         void split_dyn_RCU_GPB_base_cmp_lazy();
1395         void split_dyn_RCU_GPB_base_less_lazy();
1396         void split_dyn_RCU_GPB_base_cmpmix_lazy();
1397         void split_dyn_RCU_GPB_base_cmpmix_stat_lazy();
1398         void split_dyn_RCU_GPB_member_cmp_lazy();
1399         void split_dyn_RCU_GPB_member_less_lazy();
1400         void split_dyn_RCU_GPB_member_cmpmix_lazy();
1401         void split_dyn_RCU_GPB_member_cmpmix_stat_lazy();
1402         void split_st_RCU_GPB_base_cmp_lazy();
1403         void split_st_RCU_GPB_base_less_lazy();
1404         void split_st_RCU_GPB_base_cmpmix_lazy();
1405         void split_st_RCU_GPB_base_cmpmix_stat_lazy();
1406         void split_st_RCU_GPB_member_cmp_lazy();
1407         void split_st_RCU_GPB_member_less_lazy();
1408         void split_st_RCU_GPB_member_cmpmix_lazy();
1409         void split_st_RCU_GPB_member_cmpmix_stat_lazy();
1410
1411         void split_dyn_RCU_GPT_base_cmp_lazy();
1412         void split_dyn_RCU_GPT_base_less_lazy();
1413         void split_dyn_RCU_GPT_base_cmpmix_lazy();
1414         void split_dyn_RCU_GPT_base_cmpmix_stat_lazy();
1415         void split_dyn_RCU_GPT_member_cmp_lazy();
1416         void split_dyn_RCU_GPT_member_less_lazy();
1417         void split_dyn_RCU_GPT_member_cmpmix_lazy();
1418         void split_dyn_RCU_GPT_member_cmpmix_stat_lazy();
1419         void split_st_RCU_GPT_base_cmp_lazy();
1420         void split_st_RCU_GPT_base_less_lazy();
1421         void split_st_RCU_GPT_base_cmpmix_lazy();
1422         void split_st_RCU_GPT_base_cmpmix_stat_lazy();
1423         void split_st_RCU_GPT_member_cmp_lazy();
1424         void split_st_RCU_GPT_member_less_lazy();
1425         void split_st_RCU_GPT_member_cmpmix_lazy();
1426         void split_st_RCU_GPT_member_cmpmix_stat_lazy();
1427
1428         void split_dyn_RCU_SHB_base_cmp_lazy();
1429         void split_dyn_RCU_SHB_base_less_lazy();
1430         void split_dyn_RCU_SHB_base_cmpmix_lazy();
1431         void split_dyn_RCU_SHB_base_cmpmix_stat_lazy();
1432         void split_dyn_RCU_SHB_member_cmp_lazy();
1433         void split_dyn_RCU_SHB_member_less_lazy();
1434         void split_dyn_RCU_SHB_member_cmpmix_lazy();
1435         void split_dyn_RCU_SHB_member_cmpmix_stat_lazy();
1436         void split_st_RCU_SHB_base_cmp_lazy();
1437         void split_st_RCU_SHB_base_less_lazy();
1438         void split_st_RCU_SHB_base_cmpmix_lazy();
1439         void split_st_RCU_SHB_base_cmpmix_stat_lazy();
1440         void split_st_RCU_SHB_member_cmp_lazy();
1441         void split_st_RCU_SHB_member_less_lazy();
1442         void split_st_RCU_SHB_member_cmpmix_lazy();
1443         void split_st_RCU_SHB_member_cmpmix_stat_lazy();
1444
1445         void split_dyn_RCU_SHT_base_cmp_lazy();
1446         void split_dyn_RCU_SHT_base_less_lazy();
1447         void split_dyn_RCU_SHT_base_cmpmix_lazy();
1448         void split_dyn_RCU_SHT_base_cmpmix_stat_lazy();
1449         void split_dyn_RCU_SHT_member_cmp_lazy();
1450         void split_dyn_RCU_SHT_member_less_lazy();
1451         void split_dyn_RCU_SHT_member_cmpmix_lazy();
1452         void split_dyn_RCU_SHT_member_cmpmix_stat_lazy();
1453         void split_st_RCU_SHT_base_cmp_lazy();
1454         void split_st_RCU_SHT_base_less_lazy();
1455         void split_st_RCU_SHT_base_cmpmix_lazy();
1456         void split_st_RCU_SHT_base_cmpmix_stat_lazy();
1457         void split_st_RCU_SHT_member_cmp_lazy();
1458         void split_st_RCU_SHT_member_less_lazy();
1459         void split_st_RCU_SHT_member_cmpmix_lazy();
1460         void split_st_RCU_SHT_member_cmpmix_stat_lazy();
1461
1462         void split_dyn_nogc_base_cmp_lazy();
1463         void split_dyn_nogc_base_less_lazy();
1464         void split_dyn_nogc_base_cmpmix_lazy();
1465         void split_dyn_nogc_base_cmpmix_stat_lazy();
1466         void split_dyn_nogc_member_cmp_lazy();
1467         void split_dyn_nogc_member_less_lazy();
1468         void split_dyn_nogc_member_cmpmix_lazy();
1469         void split_dyn_nogc_member_cmpmix_stat_lazy();
1470         void split_st_nogc_base_cmp_lazy();
1471         void split_st_nogc_base_less_lazy();
1472         void split_st_nogc_base_cmpmix_lazy();
1473         void split_st_nogc_base_cmpmix_stat_lazy();
1474         void split_st_nogc_member_cmp_lazy();
1475         void split_st_nogc_member_less_lazy();
1476         void split_st_nogc_member_cmpmix_lazy();
1477         void split_st_nogc_member_cmpmix_stat_lazy();
1478
1479         CPPUNIT_TEST_SUITE(IntrusiveHashSetHdrTest)
1480             CPPUNIT_TEST(HP_base_cmp)
1481             CPPUNIT_TEST(HP_base_less)
1482             CPPUNIT_TEST(HP_base_cmpmix)
1483             CPPUNIT_TEST(HP_member_cmp)
1484             CPPUNIT_TEST(HP_member_less)
1485             CPPUNIT_TEST(HP_member_cmpmix)
1486
1487             CPPUNIT_TEST(DHP_base_cmp)
1488             CPPUNIT_TEST(DHP_base_less)
1489             CPPUNIT_TEST(DHP_base_cmpmix)
1490             CPPUNIT_TEST(DHP_member_cmp)
1491             CPPUNIT_TEST(DHP_member_less)
1492             CPPUNIT_TEST(DHP_member_cmpmix)
1493
1494             CPPUNIT_TEST(RCU_GPI_base_cmp)
1495             CPPUNIT_TEST(RCU_GPI_base_less)
1496             CPPUNIT_TEST(RCU_GPI_base_cmpmix)
1497             CPPUNIT_TEST(RCU_GPI_member_cmp)
1498             CPPUNIT_TEST(RCU_GPI_member_less)
1499             CPPUNIT_TEST(RCU_GPI_member_cmpmix)
1500
1501             CPPUNIT_TEST(RCU_GPB_base_cmp)
1502             CPPUNIT_TEST(RCU_GPB_base_less)
1503             CPPUNIT_TEST(RCU_GPB_base_cmpmix)
1504             CPPUNIT_TEST(RCU_GPB_member_cmp)
1505             CPPUNIT_TEST(RCU_GPB_member_less)
1506             CPPUNIT_TEST(RCU_GPB_member_cmpmix)
1507
1508             CPPUNIT_TEST(RCU_GPT_base_cmp)
1509             CPPUNIT_TEST(RCU_GPT_base_less)
1510             CPPUNIT_TEST(RCU_GPT_base_cmpmix)
1511             CPPUNIT_TEST(RCU_GPT_member_cmp)
1512             CPPUNIT_TEST(RCU_GPT_member_less)
1513             CPPUNIT_TEST(RCU_GPT_member_cmpmix)
1514
1515             CPPUNIT_TEST(RCU_SHB_base_cmp)
1516             CPPUNIT_TEST(RCU_SHB_base_less)
1517             CPPUNIT_TEST(RCU_SHB_base_cmpmix)
1518             CPPUNIT_TEST(RCU_SHB_member_cmp)
1519             CPPUNIT_TEST(RCU_SHB_member_less)
1520             CPPUNIT_TEST(RCU_SHB_member_cmpmix)
1521
1522             CPPUNIT_TEST(RCU_SHT_base_cmp)
1523             CPPUNIT_TEST(RCU_SHT_base_less)
1524             CPPUNIT_TEST(RCU_SHT_base_cmpmix)
1525             CPPUNIT_TEST(RCU_SHT_member_cmp)
1526             CPPUNIT_TEST(RCU_SHT_member_less)
1527             CPPUNIT_TEST(RCU_SHT_member_cmpmix)
1528
1529             CPPUNIT_TEST(nogc_base_cmp)
1530             CPPUNIT_TEST(nogc_base_less)
1531             CPPUNIT_TEST(nogc_base_cmpmix)
1532             CPPUNIT_TEST(nogc_member_cmp)
1533             CPPUNIT_TEST(nogc_member_less)
1534             CPPUNIT_TEST(nogc_member_cmpmix)
1535
1536             CPPUNIT_TEST(HP_base_cmp_lazy)
1537             CPPUNIT_TEST(HP_base_less_lazy)
1538             CPPUNIT_TEST(HP_base_cmpmix_lazy)
1539             CPPUNIT_TEST(HP_member_cmp_lazy)
1540             CPPUNIT_TEST(HP_member_less_lazy)
1541             CPPUNIT_TEST(HP_member_cmpmix_lazy)
1542
1543             CPPUNIT_TEST(DHP_base_cmp_lazy)
1544             CPPUNIT_TEST(DHP_base_less_lazy)
1545             CPPUNIT_TEST(DHP_base_cmpmix_lazy)
1546             CPPUNIT_TEST(DHP_member_cmp_lazy)
1547             CPPUNIT_TEST(DHP_member_less_lazy)
1548             CPPUNIT_TEST(DHP_member_cmpmix_lazy)
1549
1550             CPPUNIT_TEST(RCU_GPI_base_cmp_lazy)
1551             CPPUNIT_TEST(RCU_GPI_base_less_lazy)
1552             CPPUNIT_TEST(RCU_GPI_base_cmpmix_lazy)
1553             CPPUNIT_TEST(RCU_GPI_member_cmp_lazy)
1554             CPPUNIT_TEST(RCU_GPI_member_less_lazy)
1555             CPPUNIT_TEST(RCU_GPI_member_cmpmix_lazy)
1556
1557             CPPUNIT_TEST(RCU_GPB_base_cmp_lazy)
1558             CPPUNIT_TEST(RCU_GPB_base_less_lazy)
1559             CPPUNIT_TEST(RCU_GPB_base_cmpmix_lazy)
1560             CPPUNIT_TEST(RCU_GPB_member_cmp_lazy)
1561             CPPUNIT_TEST(RCU_GPB_member_less_lazy)
1562             CPPUNIT_TEST(RCU_GPB_member_cmpmix_lazy)
1563
1564             CPPUNIT_TEST(RCU_GPT_base_cmp_lazy)
1565             CPPUNIT_TEST(RCU_GPT_base_less_lazy)
1566             CPPUNIT_TEST(RCU_GPT_base_cmpmix_lazy)
1567             CPPUNIT_TEST(RCU_GPT_member_cmp_lazy)
1568             CPPUNIT_TEST(RCU_GPT_member_less_lazy)
1569             CPPUNIT_TEST(RCU_GPT_member_cmpmix_lazy)
1570
1571             CPPUNIT_TEST(RCU_SHB_base_cmp_lazy)
1572             CPPUNIT_TEST(RCU_SHB_base_less_lazy)
1573             CPPUNIT_TEST(RCU_SHB_base_cmpmix_lazy)
1574             CPPUNIT_TEST(RCU_SHB_member_cmp_lazy)
1575             CPPUNIT_TEST(RCU_SHB_member_less_lazy)
1576             CPPUNIT_TEST(RCU_SHB_member_cmpmix_lazy)
1577
1578             CPPUNIT_TEST(RCU_SHT_base_cmp_lazy)
1579             CPPUNIT_TEST(RCU_SHT_base_less_lazy)
1580             CPPUNIT_TEST(RCU_SHT_base_cmpmix_lazy)
1581             CPPUNIT_TEST(RCU_SHT_member_cmp_lazy)
1582             CPPUNIT_TEST(RCU_SHT_member_less_lazy)
1583             CPPUNIT_TEST(RCU_SHT_member_cmpmix_lazy)
1584
1585             CPPUNIT_TEST(nogc_base_cmp_lazy)
1586             CPPUNIT_TEST(nogc_base_less_lazy)
1587             CPPUNIT_TEST(nogc_base_cmpmix_lazy)
1588             CPPUNIT_TEST(nogc_member_cmp_lazy)
1589             CPPUNIT_TEST(nogc_member_less_lazy)
1590             CPPUNIT_TEST(nogc_member_cmpmix_lazy)
1591
1592             CPPUNIT_TEST(split_dyn_HP_base_cmp)
1593             CPPUNIT_TEST(split_dyn_HP_base_less)
1594             CPPUNIT_TEST(split_dyn_HP_base_cmpmix)
1595             CPPUNIT_TEST( split_dyn_HP_base_cmpmix_stat )
1596             CPPUNIT_TEST( split_dyn_HP_member_cmp )
1597             CPPUNIT_TEST(split_dyn_HP_member_less)
1598             CPPUNIT_TEST(split_dyn_HP_member_cmpmix)
1599             CPPUNIT_TEST( split_dyn_HP_member_cmpmix_stat )
1600             CPPUNIT_TEST( split_st_HP_base_cmp )
1601             CPPUNIT_TEST(split_st_HP_base_less)
1602             CPPUNIT_TEST(split_st_HP_base_cmpmix)
1603             CPPUNIT_TEST( split_st_HP_base_cmpmix_stat )
1604             CPPUNIT_TEST( split_st_HP_member_cmp )
1605             CPPUNIT_TEST(split_st_HP_member_less)
1606             CPPUNIT_TEST(split_st_HP_member_cmpmix)
1607             CPPUNIT_TEST( split_st_HP_member_cmpmix_stat )
1608
1609             CPPUNIT_TEST(split_dyn_DHP_base_cmp)
1610             CPPUNIT_TEST(split_dyn_DHP_base_less)
1611             CPPUNIT_TEST(split_dyn_DHP_base_cmpmix)
1612             CPPUNIT_TEST( split_dyn_DHP_base_cmpmix_stat )
1613             CPPUNIT_TEST( split_dyn_DHP_member_cmp )
1614             CPPUNIT_TEST(split_dyn_DHP_member_less)
1615             CPPUNIT_TEST(split_dyn_DHP_member_cmpmix)
1616             CPPUNIT_TEST( split_dyn_DHP_member_cmpmix_stat )
1617             CPPUNIT_TEST( split_st_DHP_base_cmp )
1618             CPPUNIT_TEST(split_st_DHP_base_less)
1619             CPPUNIT_TEST(split_st_DHP_base_cmpmix)
1620             CPPUNIT_TEST( split_st_DHP_base_cmpmix_stat )
1621             CPPUNIT_TEST( split_st_DHP_member_cmp )
1622             CPPUNIT_TEST(split_st_DHP_member_less)
1623             CPPUNIT_TEST(split_st_DHP_member_cmpmix)
1624             CPPUNIT_TEST( split_st_DHP_member_cmpmix_stat )
1625
1626             CPPUNIT_TEST(split_dyn_RCU_GPI_base_cmp)
1627             CPPUNIT_TEST(split_dyn_RCU_GPI_base_less)
1628             CPPUNIT_TEST(split_dyn_RCU_GPI_base_cmpmix)
1629             CPPUNIT_TEST( split_dyn_RCU_GPI_base_cmpmix_stat )
1630             CPPUNIT_TEST( split_dyn_RCU_GPI_member_cmp )
1631             CPPUNIT_TEST(split_dyn_RCU_GPI_member_less)
1632             CPPUNIT_TEST(split_dyn_RCU_GPI_member_cmpmix)
1633             CPPUNIT_TEST( split_dyn_RCU_GPI_member_cmpmix_stat )
1634             CPPUNIT_TEST( split_st_RCU_GPI_base_cmp )
1635             CPPUNIT_TEST(split_st_RCU_GPI_base_less)
1636             CPPUNIT_TEST(split_st_RCU_GPI_base_cmpmix)
1637             CPPUNIT_TEST( split_st_RCU_GPI_base_cmpmix_stat )
1638             CPPUNIT_TEST( split_st_RCU_GPI_member_cmp )
1639             CPPUNIT_TEST(split_st_RCU_GPI_member_less)
1640             CPPUNIT_TEST(split_st_RCU_GPI_member_cmpmix)
1641             CPPUNIT_TEST( split_st_RCU_GPI_member_cmpmix_stat )
1642
1643             CPPUNIT_TEST(split_dyn_RCU_GPB_base_cmp)
1644             CPPUNIT_TEST(split_dyn_RCU_GPB_base_less)
1645             CPPUNIT_TEST(split_dyn_RCU_GPB_base_cmpmix)
1646             CPPUNIT_TEST( split_dyn_RCU_GPB_base_cmpmix_stat )
1647             CPPUNIT_TEST( split_dyn_RCU_GPB_member_cmp )
1648             CPPUNIT_TEST(split_dyn_RCU_GPB_member_less)
1649             CPPUNIT_TEST(split_dyn_RCU_GPB_member_cmpmix)
1650             CPPUNIT_TEST( split_dyn_RCU_GPB_member_cmpmix_stat )
1651             CPPUNIT_TEST( split_st_RCU_GPB_base_cmp )
1652             CPPUNIT_TEST(split_st_RCU_GPB_base_less)
1653             CPPUNIT_TEST(split_st_RCU_GPB_base_cmpmix)
1654             CPPUNIT_TEST( split_st_RCU_GPB_base_cmpmix_stat )
1655             CPPUNIT_TEST( split_st_RCU_GPB_member_cmp )
1656             CPPUNIT_TEST(split_st_RCU_GPB_member_less)
1657             CPPUNIT_TEST(split_st_RCU_GPB_member_cmpmix)
1658             CPPUNIT_TEST( split_st_RCU_GPB_member_cmpmix_stat )
1659
1660             CPPUNIT_TEST(split_dyn_RCU_GPT_base_cmp)
1661             CPPUNIT_TEST(split_dyn_RCU_GPT_base_less)
1662             CPPUNIT_TEST(split_dyn_RCU_GPT_base_cmpmix)
1663             CPPUNIT_TEST( split_dyn_RCU_GPT_base_cmpmix_stat )
1664             CPPUNIT_TEST( split_dyn_RCU_GPT_member_cmp )
1665             CPPUNIT_TEST(split_dyn_RCU_GPT_member_less)
1666             CPPUNIT_TEST(split_dyn_RCU_GPT_member_cmpmix)
1667             CPPUNIT_TEST( split_dyn_RCU_GPT_member_cmpmix_stat )
1668             CPPUNIT_TEST( split_st_RCU_GPT_base_cmp )
1669             CPPUNIT_TEST(split_st_RCU_GPT_base_less)
1670             CPPUNIT_TEST(split_st_RCU_GPT_base_cmpmix)
1671             CPPUNIT_TEST( split_st_RCU_GPT_base_cmpmix_stat )
1672             CPPUNIT_TEST( split_st_RCU_GPT_member_cmp )
1673             CPPUNIT_TEST(split_st_RCU_GPT_member_less)
1674             CPPUNIT_TEST(split_st_RCU_GPT_member_cmpmix)
1675             CPPUNIT_TEST( split_st_RCU_GPT_member_cmpmix_stat )
1676
1677             CPPUNIT_TEST(split_dyn_RCU_SHB_base_cmp)
1678             CPPUNIT_TEST(split_dyn_RCU_SHB_base_less)
1679             CPPUNIT_TEST(split_dyn_RCU_SHB_base_cmpmix)
1680             CPPUNIT_TEST( split_dyn_RCU_SHB_base_cmpmix_stat )
1681             CPPUNIT_TEST( split_dyn_RCU_SHB_member_cmp )
1682             CPPUNIT_TEST(split_dyn_RCU_SHB_member_less)
1683             CPPUNIT_TEST(split_dyn_RCU_SHB_member_cmpmix)
1684             CPPUNIT_TEST( split_dyn_RCU_SHB_member_cmpmix_stat )
1685             CPPUNIT_TEST( split_st_RCU_SHB_base_cmp )
1686             CPPUNIT_TEST(split_st_RCU_SHB_base_less)
1687             CPPUNIT_TEST(split_st_RCU_SHB_base_cmpmix)
1688             CPPUNIT_TEST( split_st_RCU_SHB_base_cmpmix_stat )
1689             CPPUNIT_TEST( split_st_RCU_SHB_member_cmp )
1690             CPPUNIT_TEST(split_st_RCU_SHB_member_less)
1691             CPPUNIT_TEST(split_st_RCU_SHB_member_cmpmix)
1692             CPPUNIT_TEST( split_st_RCU_SHB_member_cmpmix_stat )
1693
1694             CPPUNIT_TEST(split_dyn_RCU_SHT_base_cmp)
1695             CPPUNIT_TEST(split_dyn_RCU_SHT_base_less)
1696             CPPUNIT_TEST(split_dyn_RCU_SHT_base_cmpmix)
1697             CPPUNIT_TEST( split_dyn_RCU_SHT_base_cmpmix_stat )
1698             CPPUNIT_TEST( split_dyn_RCU_SHT_member_cmp )
1699             CPPUNIT_TEST(split_dyn_RCU_SHT_member_less)
1700             CPPUNIT_TEST(split_dyn_RCU_SHT_member_cmpmix)
1701             CPPUNIT_TEST( split_dyn_RCU_SHT_member_cmpmix_stat )
1702             CPPUNIT_TEST( split_st_RCU_SHT_base_cmp )
1703             CPPUNIT_TEST(split_st_RCU_SHT_base_less)
1704             CPPUNIT_TEST(split_st_RCU_SHT_base_cmpmix)
1705             CPPUNIT_TEST( split_st_RCU_SHT_base_cmpmix_stat )
1706             CPPUNIT_TEST( split_st_RCU_SHT_member_cmp )
1707             CPPUNIT_TEST(split_st_RCU_SHT_member_less)
1708             CPPUNIT_TEST(split_st_RCU_SHT_member_cmpmix)
1709             CPPUNIT_TEST( split_st_RCU_SHT_member_cmpmix_stat )
1710
1711             CPPUNIT_TEST(split_dyn_nogc_base_cmp)
1712             CPPUNIT_TEST(split_dyn_nogc_base_less)
1713             CPPUNIT_TEST(split_dyn_nogc_base_cmpmix)
1714             CPPUNIT_TEST( split_dyn_nogc_base_cmpmix_stat )
1715             CPPUNIT_TEST( split_dyn_nogc_member_cmp )
1716             CPPUNIT_TEST(split_dyn_nogc_member_less)
1717             CPPUNIT_TEST(split_dyn_nogc_member_cmpmix)
1718             CPPUNIT_TEST( split_dyn_nogc_member_cmpmix_stat )
1719             CPPUNIT_TEST( split_st_nogc_base_cmp )
1720             CPPUNIT_TEST(split_st_nogc_base_less)
1721             CPPUNIT_TEST(split_st_nogc_base_cmpmix)
1722             CPPUNIT_TEST( split_st_nogc_base_cmpmix_stat )
1723             CPPUNIT_TEST( split_st_nogc_member_cmp )
1724             CPPUNIT_TEST(split_st_nogc_member_less)
1725             CPPUNIT_TEST(split_st_nogc_member_cmpmix)
1726             CPPUNIT_TEST( split_st_nogc_member_cmpmix_stat )
1727
1728             CPPUNIT_TEST(split_dyn_HP_base_cmp_lazy)
1729             CPPUNIT_TEST(split_dyn_HP_base_less_lazy)
1730             CPPUNIT_TEST(split_dyn_HP_base_cmpmix_lazy)
1731             CPPUNIT_TEST( split_dyn_HP_base_cmpmix_stat_lazy )
1732             CPPUNIT_TEST( split_dyn_HP_member_cmp_lazy )
1733             CPPUNIT_TEST(split_dyn_HP_member_less_lazy)
1734             CPPUNIT_TEST(split_dyn_HP_member_cmpmix_lazy)
1735             CPPUNIT_TEST( split_dyn_HP_member_cmpmix_stat_lazy )
1736             CPPUNIT_TEST( split_st_HP_base_cmp_lazy )
1737             CPPUNIT_TEST(split_st_HP_base_less_lazy)
1738             CPPUNIT_TEST(split_st_HP_base_cmpmix_lazy)
1739             CPPUNIT_TEST( split_st_HP_base_cmpmix_stat_lazy )
1740             CPPUNIT_TEST( split_st_HP_member_cmp_lazy )
1741             CPPUNIT_TEST(split_st_HP_member_less_lazy)
1742             CPPUNIT_TEST(split_st_HP_member_cmpmix_lazy)
1743             CPPUNIT_TEST( split_st_HP_member_cmpmix_stat_lazy )
1744
1745             CPPUNIT_TEST(split_dyn_DHP_base_cmp_lazy)
1746             CPPUNIT_TEST(split_dyn_DHP_base_less_lazy)
1747             CPPUNIT_TEST(split_dyn_DHP_base_cmpmix_lazy)
1748             CPPUNIT_TEST( split_dyn_DHP_base_cmpmix_stat_lazy )
1749             CPPUNIT_TEST( split_dyn_DHP_member_cmp_lazy )
1750             CPPUNIT_TEST(split_dyn_DHP_member_less_lazy)
1751             CPPUNIT_TEST(split_dyn_DHP_member_cmpmix_lazy)
1752             CPPUNIT_TEST( split_dyn_DHP_member_cmpmix_stat_lazy )
1753             CPPUNIT_TEST( split_st_DHP_base_cmp_lazy )
1754             CPPUNIT_TEST(split_st_DHP_base_less_lazy)
1755             CPPUNIT_TEST(split_st_DHP_base_cmpmix_lazy)
1756             CPPUNIT_TEST( split_st_DHP_base_cmpmix_stat_lazy )
1757             CPPUNIT_TEST( split_st_DHP_member_cmp_lazy )
1758             CPPUNIT_TEST(split_st_DHP_member_less_lazy)
1759             CPPUNIT_TEST(split_st_DHP_member_cmpmix_lazy)
1760             CPPUNIT_TEST( split_st_DHP_member_cmpmix_stat_lazy )
1761
1762             CPPUNIT_TEST(split_dyn_RCU_GPI_base_cmp_lazy)
1763             CPPUNIT_TEST(split_dyn_RCU_GPI_base_less_lazy)
1764             CPPUNIT_TEST(split_dyn_RCU_GPI_base_cmpmix_lazy)
1765             CPPUNIT_TEST( split_dyn_RCU_GPI_base_cmpmix_stat_lazy )
1766             CPPUNIT_TEST( split_dyn_RCU_GPI_member_cmp_lazy )
1767             CPPUNIT_TEST(split_dyn_RCU_GPI_member_less_lazy)
1768             CPPUNIT_TEST(split_dyn_RCU_GPI_member_cmpmix_lazy)
1769             CPPUNIT_TEST( split_dyn_RCU_GPI_member_cmpmix_stat_lazy )
1770             CPPUNIT_TEST( split_st_RCU_GPI_base_cmp_lazy )
1771             CPPUNIT_TEST(split_st_RCU_GPI_base_less_lazy)
1772             CPPUNIT_TEST(split_st_RCU_GPI_base_cmpmix_lazy)
1773             CPPUNIT_TEST( split_st_RCU_GPI_base_cmpmix_stat_lazy )
1774             CPPUNIT_TEST( split_st_RCU_GPI_member_cmp_lazy )
1775             CPPUNIT_TEST(split_st_RCU_GPI_member_less_lazy)
1776             CPPUNIT_TEST(split_st_RCU_GPI_member_cmpmix_lazy)
1777             CPPUNIT_TEST( split_st_RCU_GPI_member_cmpmix_stat_lazy )
1778
1779             CPPUNIT_TEST(split_dyn_RCU_GPB_base_cmp_lazy)
1780             CPPUNIT_TEST(split_dyn_RCU_GPB_base_less_lazy)
1781             CPPUNIT_TEST(split_dyn_RCU_GPB_base_cmpmix_lazy)
1782             CPPUNIT_TEST( split_dyn_RCU_GPB_base_cmpmix_stat_lazy )
1783             CPPUNIT_TEST( split_dyn_RCU_GPB_member_cmp_lazy )
1784             CPPUNIT_TEST(split_dyn_RCU_GPB_member_less_lazy)
1785             CPPUNIT_TEST(split_dyn_RCU_GPB_member_cmpmix_lazy)
1786             CPPUNIT_TEST( split_dyn_RCU_GPB_member_cmpmix_stat_lazy )
1787             CPPUNIT_TEST( split_st_RCU_GPB_base_cmp_lazy )
1788             CPPUNIT_TEST(split_st_RCU_GPB_base_less_lazy)
1789             CPPUNIT_TEST(split_st_RCU_GPB_base_cmpmix_lazy)
1790             CPPUNIT_TEST( split_st_RCU_GPB_base_cmpmix_stat_lazy )
1791             CPPUNIT_TEST( split_st_RCU_GPB_member_cmp_lazy )
1792             CPPUNIT_TEST(split_st_RCU_GPB_member_less_lazy)
1793             CPPUNIT_TEST(split_st_RCU_GPB_member_cmpmix_lazy)
1794             CPPUNIT_TEST( split_st_RCU_GPB_member_cmpmix_stat_lazy )
1795
1796             CPPUNIT_TEST(split_dyn_RCU_GPT_base_cmp_lazy)
1797             CPPUNIT_TEST(split_dyn_RCU_GPT_base_less_lazy)
1798             CPPUNIT_TEST(split_dyn_RCU_GPT_base_cmpmix_lazy)
1799             CPPUNIT_TEST( split_dyn_RCU_GPT_base_cmpmix_stat_lazy )
1800             CPPUNIT_TEST( split_dyn_RCU_GPT_member_cmp_lazy )
1801             CPPUNIT_TEST(split_dyn_RCU_GPT_member_less_lazy)
1802             CPPUNIT_TEST(split_dyn_RCU_GPT_member_cmpmix_lazy)
1803             CPPUNIT_TEST( split_dyn_RCU_GPT_member_cmpmix_stat_lazy )
1804             CPPUNIT_TEST( split_st_RCU_GPT_base_cmp_lazy )
1805             CPPUNIT_TEST(split_st_RCU_GPT_base_less_lazy)
1806             CPPUNIT_TEST(split_st_RCU_GPT_base_cmpmix_lazy)
1807             CPPUNIT_TEST( split_st_RCU_GPT_base_cmpmix_stat_lazy )
1808             CPPUNIT_TEST( split_st_RCU_GPT_member_cmp_lazy )
1809             CPPUNIT_TEST(split_st_RCU_GPT_member_less_lazy)
1810             CPPUNIT_TEST(split_st_RCU_GPT_member_cmpmix_lazy)
1811             CPPUNIT_TEST( split_st_RCU_GPT_member_cmpmix_stat_lazy )
1812
1813             CPPUNIT_TEST(split_dyn_RCU_SHB_base_cmp_lazy)
1814             CPPUNIT_TEST(split_dyn_RCU_SHB_base_less_lazy)
1815             CPPUNIT_TEST(split_dyn_RCU_SHB_base_cmpmix_lazy)
1816             CPPUNIT_TEST( split_dyn_RCU_SHB_base_cmpmix_stat_lazy )
1817             CPPUNIT_TEST( split_dyn_RCU_SHB_member_cmp_lazy )
1818             CPPUNIT_TEST(split_dyn_RCU_SHB_member_less_lazy)
1819             CPPUNIT_TEST(split_dyn_RCU_SHB_member_cmpmix_lazy)
1820             CPPUNIT_TEST( split_dyn_RCU_SHB_member_cmpmix_stat_lazy )
1821             CPPUNIT_TEST( split_st_RCU_SHB_base_cmp_lazy )
1822             CPPUNIT_TEST(split_st_RCU_SHB_base_less_lazy)
1823             CPPUNIT_TEST(split_st_RCU_SHB_base_cmpmix_lazy)
1824             CPPUNIT_TEST( split_st_RCU_SHB_base_cmpmix_stat_lazy )
1825             CPPUNIT_TEST( split_st_RCU_SHB_member_cmp_lazy )
1826             CPPUNIT_TEST(split_st_RCU_SHB_member_less_lazy)
1827             CPPUNIT_TEST(split_st_RCU_SHB_member_cmpmix_lazy)
1828             CPPUNIT_TEST( split_st_RCU_SHB_member_cmpmix_stat_lazy )
1829
1830             CPPUNIT_TEST(split_dyn_RCU_SHT_base_cmp_lazy)
1831             CPPUNIT_TEST(split_dyn_RCU_SHT_base_less_lazy)
1832             CPPUNIT_TEST(split_dyn_RCU_SHT_base_cmpmix_lazy)
1833             CPPUNIT_TEST( split_dyn_RCU_SHT_base_cmpmix_stat_lazy )
1834             CPPUNIT_TEST( split_dyn_RCU_SHT_member_cmp_lazy )
1835             CPPUNIT_TEST(split_dyn_RCU_SHT_member_less_lazy)
1836             CPPUNIT_TEST(split_dyn_RCU_SHT_member_cmpmix_lazy)
1837             CPPUNIT_TEST( split_dyn_RCU_SHT_member_cmpmix_stat_lazy )
1838             CPPUNIT_TEST( split_st_RCU_SHT_base_cmp_lazy )
1839             CPPUNIT_TEST(split_st_RCU_SHT_base_less_lazy)
1840             CPPUNIT_TEST(split_st_RCU_SHT_base_cmpmix_lazy)
1841             CPPUNIT_TEST( split_st_RCU_SHT_base_cmpmix_stat_lazy )
1842             CPPUNIT_TEST( split_st_RCU_SHT_member_cmp_lazy )
1843             CPPUNIT_TEST(split_st_RCU_SHT_member_less_lazy)
1844             CPPUNIT_TEST(split_st_RCU_SHT_member_cmpmix_lazy)
1845             CPPUNIT_TEST( split_st_RCU_SHT_member_cmpmix_stat_lazy )
1846
1847             CPPUNIT_TEST(split_dyn_nogc_base_cmp_lazy)
1848             CPPUNIT_TEST(split_dyn_nogc_base_less_lazy)
1849             CPPUNIT_TEST(split_dyn_nogc_base_cmpmix_lazy)
1850             CPPUNIT_TEST( split_dyn_nogc_base_cmpmix_stat_lazy )
1851             CPPUNIT_TEST( split_dyn_nogc_member_cmp_lazy )
1852             CPPUNIT_TEST(split_dyn_nogc_member_less_lazy)
1853             CPPUNIT_TEST(split_dyn_nogc_member_cmpmix_lazy)
1854             CPPUNIT_TEST( split_dyn_nogc_member_cmpmix_stat_lazy )
1855             CPPUNIT_TEST( split_st_nogc_base_cmp_lazy )
1856             CPPUNIT_TEST(split_st_nogc_base_less_lazy)
1857             CPPUNIT_TEST(split_st_nogc_base_cmpmix_lazy)
1858             CPPUNIT_TEST( split_st_nogc_base_cmpmix_stat_lazy )
1859             CPPUNIT_TEST( split_st_nogc_member_cmp_lazy )
1860             CPPUNIT_TEST(split_st_nogc_member_less_lazy)
1861             CPPUNIT_TEST(split_st_nogc_member_cmpmix_lazy)
1862             CPPUNIT_TEST( split_st_nogc_member_cmpmix_stat_lazy )
1863         CPPUNIT_TEST_SUITE_END()
1864
1865     };
1866
1867 }   // namespace set