tests/test-hdr/set/hdr_intrusive_set.h

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