tests/test-hdr/set/hdr_intrusive_set.h

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