tests/test-hdr/set/hdr_intrusive_set.h

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