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