tests/test-hdr/set/hdr_intrusive_set.h

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