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