tests/test-hdr/tree/hdr_bronson_avltree_map.h

   1 //$$CDS-header$$
   2
   3 #ifndef CDSTEST_HDR_BRONSON_AVLTREE_MAP_H
   4 #define CDSTEST_HDR_BRONSON_AVLTREE_MAP_H
   5
   6 #include "cppunit/cppunit_proxy.h"
   7 #include "size_check.h"
   8 #include <functional>   // ref
   9 #include <algorithm>
  10
  11 namespace tree {
  12     using misc::check_size;
  13
  14     class BronsonAVLTreeHdrTest : public CppUnitMini::TestCase
  15     {
  16     public:
  17         typedef int     key_type;
  18
  19         struct stat_data {
  20             size_t  nInsertFuncCall;
  21             size_t  nEnsureExistFuncCall;
  22             size_t  nEnsureNewFuncCall;
  23             size_t  nEraseFuncCall;
  24             size_t  nFindFuncCall;
  25
  26             stat_data()
  27                 : nInsertFuncCall( 0 )
  28                 , nEnsureExistFuncCall( 0 )
  29                 , nEnsureNewFuncCall( 0 )
  30                 , nEraseFuncCall( 0 )
  31                 , nFindFuncCall( 0 )
  32             {}
  33         };
  34
  35         struct value_type {
  36             int         nVal;
  37             stat_data   stat;
  38
  39             value_type()
  40                 : nVal(0)
  41             {}
  42
  43             value_type( int v )
  44                 : nVal( v )
  45             {}
  46         };
  47
  48         struct compare {
  49             int operator()( key_type k1, key_type k2 )
  50             {
  51                 return k1 < k2 ? -1 : k1 > k2 ? 1 : 0;
  52             }
  53         };
  54
  55         struct wrapped_int {
  56             int  nKey;
  57
  58             wrapped_int( int n )
  59                 : nKey( n )
  60             {}
  61         };
  62
  63         struct wrapped_less
  64         {
  65             bool operator()( wrapped_int const& w, int n ) const
  66             {
  67                 return w.nKey < n;
  68             }
  69             bool operator()( int n, wrapped_int const& w ) const
  70             {
  71                 return n < w.nKey;
  72             }
  73             template <typename T>
  74             bool operator()( wrapped_int const& w, T const& v ) const
  75             {
  76                 return w.nKey < v.nKey;
  77             }
  78             template <typename T>
  79             bool operator()( T const& v, wrapped_int const& w ) const
  80             {
  81                 return v.nKey < w.nKey;
  82             }
  83         };
  84
  85     protected:
  86         static const size_t c_nItemCount = 10000;
  87
  88         class data_array
  89         {
  90             int *     pFirst;
  91             int *     pLast;
  92
  93         public:
  94             data_array()
  95                 : pFirst( new int[c_nItemCount] )
  96                 , pLast( pFirst + c_nItemCount )
  97             {
  98                 int i = 0;
  99                 for ( int * p = pFirst; p != pLast; ++p, ++i )
 100                     *p = i;
 101
 102                 std::random_shuffle( pFirst, pLast );
 103             }
 104
 105             ~data_array()
 106             {
 107                 delete[] pFirst;
 108             }
 109
 110             int operator[]( size_t i ) const
 111             {
 112                 assert( i < size_t( pLast - pFirst ) );
 113                 return pFirst[i];
 114             }
 115         };
 116
 117         struct find_functor
 118         {
 119             void operator()( key_type, value_type& v ) const
 120             {
 121                 ++v.stat.nFindFuncCall;
 122             }
 123         };
 124
 125         template <typename Item>
 126         struct copy_found
 127         {
 128             Item    m_found;
 129
 130             void operator()( key_type const&, Item& v )
 131             {
 132                 m_found = v;
 133             }
 134
 135             void operator()( Item& v )
 136             {
 137                 m_found = v;
 138             }
 139         };
 140
 141         struct insert_functor
 142         {
 143             template <typename Item>
 144             void operator()( key_type key, Item& i )
 145             {
 146                 i.nVal = key * 100;
 147                 ++i.stat.nInsertFuncCall;
 148             }
 149         };
 150
 151         template <typename Q>
 152         static void ensure_func( bool bNew, Q key, value_type& i )
 153         {
 154             i.nVal = key * 100;
 155             if ( bNew )
 156                 ++i.stat.nEnsureNewFuncCall;
 157             else
 158                 ++i.stat.nEnsureExistFuncCall;
 159         }
 160
 161         struct ensure_functor
 162         {
 163             template <typename Q>
 164             void operator()( bool bNew, Q key, value_type& i )
 165             {
 166                 ensure_func( bNew, key, i );
 167             }
 168         };
 169
 170     protected:
 171         template <class Set>
 172         void test_with( Set& s )
 173         {
 174             value_type itm;
 175             int key;
 176             typedef typename Set::exempt_ptr exempt_ptr;
 177
 178             // insert/find test
 179             CPPUNIT_ASSERT( !s.find( 10 ) );
 180             CPPUNIT_ASSERT( s.insert( 10 ) );
 181             CPPUNIT_ASSERT( !s.empty() );
 182             CPPUNIT_ASSERT( check_size( s, 1 ) );
 183             CPPUNIT_ASSERT( s.find( 10 ) );
 184
 185             CPPUNIT_ASSERT( !s.insert( 10 ) );
 186             CPPUNIT_ASSERT( !s.empty() );
 187             CPPUNIT_ASSERT( check_size( s, 1 ) );
 188
 189             CPPUNIT_ASSERT( !s.find_with( 20, std::less<key_type>() ) );
 190             CPPUNIT_ASSERT( s.insert( 20, 25 ) );
 191             CPPUNIT_ASSERT( !s.empty() );
 192             CPPUNIT_ASSERT( check_size( s, 2 ) );
 193             CPPUNIT_ASSERT( s.find_with( 10, std::less<key_type>() ) );
 194             CPPUNIT_ASSERT( s.find( key = 20 ) );
 195             CPPUNIT_ASSERT( s.find_with( key, std::less<key_type>(), find_functor() ) );
 196             {
 197                 copy_found<value_type> f;
 198                 key = 20;
 199                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
 200                 CPPUNIT_ASSERT( f.m_found.nVal == 25 );
 201                 CPPUNIT_ASSERT( f.m_found.stat.nFindFuncCall == 1 );
 202             }
 203             CPPUNIT_ASSERT( s.find( key, find_functor() ) );
 204             {
 205                 copy_found<value_type> f;
 206                 key = 20;
 207                 CPPUNIT_ASSERT( s.find_with( key, std::less<key_type>(), std::ref( f ) ) );
 208                 CPPUNIT_ASSERT( f.m_found.nVal == 25 );
 209                 CPPUNIT_ASSERT( f.m_found.stat.nFindFuncCall == 2 );
 210             }
 211             CPPUNIT_ASSERT( s.find( 20, find_functor() ) );
 212             {
 213                 copy_found<value_type> f;
 214                 CPPUNIT_ASSERT( s.find_with( 20, std::less<key_type>(), std::ref( f ) ) );
 215                 CPPUNIT_ASSERT( f.m_found.nVal == 25 );
 216                 CPPUNIT_ASSERT( f.m_found.stat.nFindFuncCall == 3 );
 217             }
 218
 219             CPPUNIT_ASSERT( !s.empty() );
 220             CPPUNIT_ASSERT( check_size( s, 2 ) );
 221
 222             CPPUNIT_ASSERT( !s.find( 25 ) );
 223             CPPUNIT_ASSERT( s.insert_with( 25, insert_functor() ) );
 224             CPPUNIT_ASSERT( !s.empty() );
 225             CPPUNIT_ASSERT( check_size( s, 3 ) );
 226             {
 227                 copy_found<value_type> f;
 228                 key = 25;
 229                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
 230                 CPPUNIT_ASSERT( f.m_found.nVal == 2500 );
 231                 CPPUNIT_ASSERT( f.m_found.stat.nInsertFuncCall == 1 );
 232             }
 233
 234             // update test
 235             key = 10;
 236             {
 237                 copy_found<value_type> f;
 238                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
 239                 CPPUNIT_ASSERT( f.m_found.nVal == 0 );
 240                 CPPUNIT_ASSERT( f.m_found.stat.nEnsureExistFuncCall == 0 );
 241                 CPPUNIT_ASSERT( f.m_found.stat.nEnsureNewFuncCall == 0 );
 242             }
 243             std::pair<bool, bool> ensureResult = s.update( key, ensure_functor() );
 244             CPPUNIT_ASSERT( ensureResult.first && !ensureResult.second );
 245             CPPUNIT_ASSERT( !s.empty() );
 246             CPPUNIT_ASSERT( check_size( s, 3 ) );
 247             {
 248                 copy_found<value_type> f;
 249                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
 250                 CPPUNIT_ASSERT( f.m_found.nVal == 1000 );
 251                 CPPUNIT_ASSERT( f.m_found.stat.nEnsureExistFuncCall == 1 );
 252                 CPPUNIT_ASSERT( f.m_found.stat.nEnsureNewFuncCall == 0 );
 253             }
 254
 255             ensureResult = s.update( 13, []( bool /*bNew*/, key_type key, value_type& v )
 256                 {
 257                     v.nVal = key * 1000;
 258                     ++v.stat.nEnsureNewFuncCall;
 259                 });
 260             CPPUNIT_ASSERT( ensureResult.first && ensureResult.second );
 261             CPPUNIT_ASSERT( !s.empty() );
 262             CPPUNIT_ASSERT( check_size( s, 4 ) );
 263             {
 264                 copy_found<value_type> f;
 265                 key = 13;
 266                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
 267                 CPPUNIT_ASSERT( f.m_found.nVal == 13000 );
 268                 CPPUNIT_ASSERT( f.m_found.stat.nEnsureExistFuncCall == 0 );
 269                 CPPUNIT_ASSERT( f.m_found.stat.nEnsureNewFuncCall == 1 );
 270             }
 271
 272             // erase test
 273             CPPUNIT_ASSERT( s.erase( 13 ) );
 274             CPPUNIT_ASSERT( !s.find( 13 ) );
 275             CPPUNIT_ASSERT( !s.empty() );
 276             CPPUNIT_ASSERT( check_size( s, 3 ) );
 277             CPPUNIT_ASSERT( !s.erase( 13 ) );
 278             CPPUNIT_ASSERT( !s.empty() );
 279             CPPUNIT_ASSERT( check_size( s, 3 ) );
 280
 281             CPPUNIT_ASSERT( s.find( 10 ) );
 282             CPPUNIT_ASSERT( s.erase_with( 10, std::less<key_type>() ) );
 283             CPPUNIT_ASSERT( !s.find( 10 ) );
 284             CPPUNIT_ASSERT( !s.empty() );
 285             CPPUNIT_ASSERT( check_size( s, 2 ) );
 286             CPPUNIT_ASSERT( !s.erase_with( 10, std::less<key_type>() ) );
 287             CPPUNIT_ASSERT( !s.empty() );
 288             CPPUNIT_ASSERT( check_size( s, 2 ) );
 289
 290             CPPUNIT_ASSERT( s.find( 20 ) );
 291             {
 292                 copy_found<value_type> f;
 293                 CPPUNIT_ASSERT( s.erase( 20, std::ref( f ) ) );
 294                 CPPUNIT_ASSERT( f.m_found.nVal == 25 );
 295
 296                 CPPUNIT_ASSERT( s.insert( 235, 2350 ) );
 297                 CPPUNIT_ASSERT( s.erase_with( 235, std::less<key_type>(), std::ref( f ) ) );
 298                 CPPUNIT_ASSERT( f.m_found.nVal == 2350 );
 299             }
 300             CPPUNIT_ASSERT( !s.find( 20 ) );
 301             CPPUNIT_ASSERT( !s.empty() );
 302             CPPUNIT_ASSERT( check_size( s, 1 ) );
 303
 304             s.clear();
 305             CPPUNIT_ASSERT( s.empty() );
 306             CPPUNIT_ASSERT( check_size( s, 0 ) );
 307
 308             // emplace test
 309             CPPUNIT_ASSERT( s.emplace( 151 ) );  // key = 151, val=0
 310             CPPUNIT_ASSERT( s.emplace( 174, 471 ) );    // key = 174, val = 471
 311             CPPUNIT_ASSERT( !s.empty() );
 312             CPPUNIT_ASSERT( check_size( s, 2 ) );
 313
 314             CPPUNIT_ASSERT( s.find( 151 ) );
 315             CPPUNIT_ASSERT( s.find_with( 174, std::less<key_type>() ) );
 316             CPPUNIT_ASSERT( !s.find( 190 ) );
 317
 318             {
 319                 copy_found<value_type> f;
 320                 key = 151;
 321                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
 322                 CPPUNIT_ASSERT( f.m_found.nVal == 0 );
 323
 324                 key = 174;
 325                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
 326                 CPPUNIT_ASSERT( f.m_found.nVal == 471 );
 327             }
 328
 329             s.clear();
 330             CPPUNIT_ASSERT( s.empty() );
 331             CPPUNIT_ASSERT( check_size( s, 0 ) );
 332
 333             const int c_nStep = 10;
 334             int keys[1000];
 335             for ( key_type i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 336                 keys[i] = i;
 337             std::random_shuffle( keys, keys + sizeof(keys) / sizeof(keys[0]));
 338
 339             size_t nCount = 1;
 340             int nPrev;
 341             key_type keyPrev;
 342             exempt_ptr xp;
 343
 344             // extract_min
 345             for ( int i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 346                 CPPUNIT_ASSERT( s.emplace( keys[i], keys[i] * c_nStep ));
 347
 348             xp = s.extract_min();
 349             CPPUNIT_ASSERT( xp );
 350             nPrev = xp->nVal;
 351             CPPUNIT_CHECK_EX( nPrev == 0, "Expected=0 real=" << nPrev );
 352             while ( !s.empty() ) {
 353                 xp = s.extract_min();
 354                 CPPUNIT_ASSERT( xp );
 355                 CPPUNIT_CHECK_EX( nPrev + c_nStep == xp->nVal, "Expected=" << nPrev + c_nStep << " real=" << xp->nVal );
 356                 nPrev = xp->nVal;
 357                 ++nCount;
 358             }
 359             CPPUNIT_CHECK( nCount == sizeof(keys) / sizeof(keys[0]));
 360
 361             // extract_min<Func>
 362             for ( int i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 363                 CPPUNIT_ASSERT( s.insert( keys[i], keys[i] * c_nStep ));
 364
 365             nCount = 1;
 366             xp = s.extract_min( [&keyPrev]( key_type k ){ keyPrev = k; });
 367             CPPUNIT_ASSERT( xp );
 368             nPrev = xp->nVal;
 369             CPPUNIT_CHECK_EX( keyPrev == 0, "Expected=0 real=" << keyPrev );
 370             CPPUNIT_CHECK_EX( nPrev == 0, "Expected=0 real=" << nPrev );
 371             while ( !s.empty() ) {
 372                 xp = s.extract_min( [&key](key_type k){ key = k; } );
 373                 CPPUNIT_ASSERT( xp );
 374                 CPPUNIT_CHECK_EX( key == keyPrev + 1, "Expected=" << keyPrev + 1 << " real=" << key );
 375                 CPPUNIT_CHECK_EX( nPrev + c_nStep == xp->nVal, "Expected=" << nPrev + c_nStep << " real=" << xp->nVal );
 376                 nPrev = xp->nVal;
 377                 ++keyPrev;
 378                 ++nCount;
 379             }
 380             CPPUNIT_CHECK( nCount == sizeof(keys) / sizeof(keys[0]));
 381
 382             // extract_min_key
 383             for ( int i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 384                 CPPUNIT_ASSERT( s.insert( keys[i], keys[i] * c_nStep ));
 385
 386             nCount = 1;
 387             xp = s.extract_min_key( keyPrev );
 388             CPPUNIT_ASSERT( xp );
 389             nPrev = xp->nVal;
 390             CPPUNIT_CHECK_EX( keyPrev == 0, "Expected=0 real=" << keyPrev );
 391             CPPUNIT_CHECK_EX( nPrev == 0, "Expected=0 real=" << nPrev );
 392             while ( !s.empty() ) {
 393                 xp = s.extract_min_key( key );
 394                 CPPUNIT_ASSERT( xp );
 395                 CPPUNIT_CHECK_EX( key == keyPrev + 1, "Expected=" << keyPrev + 1 << " real=" << key );
 396                 CPPUNIT_CHECK_EX( nPrev + c_nStep == xp->nVal, "Expected=" << nPrev + c_nStep << " real=" << xp->nVal );
 397                 nPrev = xp->nVal;
 398                 ++keyPrev;
 399                 ++nCount;
 400             }
 401             CPPUNIT_CHECK( nCount == sizeof(keys) / sizeof(keys[0]));
 402
 403             // extract_max
 404             for ( int i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 405                 CPPUNIT_ASSERT( s.emplace( keys[i], keys[i] * c_nStep ));
 406
 407             nCount = 1;
 408             xp = s.extract_max();
 409             CPPUNIT_ASSERT( xp );
 410             nPrev = xp->nVal;
 411             CPPUNIT_CHECK_EX( nPrev == c_nStep * (sizeof(keys) / sizeof(keys[0]) - 1),
 412                 "Expected=" << c_nStep * (sizeof(keys) / sizeof(keys[0]) - 1) << " real=" << nPrev );
 413             while ( !s.empty() ) {
 414                 xp = s.extract_max();
 415                 CPPUNIT_ASSERT( xp );
 416                 CPPUNIT_CHECK_EX( nPrev - c_nStep == xp->nVal, "Expected=" << nPrev - c_nStep << " real=" << xp->nVal );
 417                 nPrev = xp->nVal;
 418                 ++nCount;
 419             }
 420             CPPUNIT_CHECK( nCount == sizeof(keys) / sizeof(keys[0]));
 421
 422             // extract_max<Func>
 423             for ( int i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 424                 CPPUNIT_ASSERT( s.emplace( keys[i], keys[i] * c_nStep ));
 425
 426             nCount = 1;
 427             xp = s.extract_max( [&keyPrev]( key_type k ){ keyPrev = k; });
 428             CPPUNIT_ASSERT( xp );
 429             nPrev = xp->nVal;
 430             CPPUNIT_CHECK_EX( keyPrev == sizeof(keys) / sizeof(keys[0]) - 1,
 431                 "Expected=" << sizeof(keys) / sizeof(keys[0]) - 1 << " real=" << keyPrev );
 432             CPPUNIT_CHECK_EX( nPrev == c_nStep * (sizeof(keys) / sizeof(keys[0]) - 1),
 433                 "Expected=" << c_nStep * (sizeof(keys) / sizeof(keys[0]) - 1) << " real=" << nPrev );
 434             while ( !s.empty() ) {
 435                 xp = s.extract_max( [&key](key_type k){ key = k; });
 436                 CPPUNIT_ASSERT( xp );
 437                 CPPUNIT_CHECK_EX( key == keyPrev - 1, "Expected=" << keyPrev - 1 << " real=" << key );
 438                 CPPUNIT_CHECK_EX( nPrev - c_nStep == xp->nVal, "Expected=" << nPrev - c_nStep << " real=" << xp->nVal );
 439                 nPrev = xp->nVal;
 440                 --keyPrev;
 441                 ++nCount;
 442             }
 443             CPPUNIT_CHECK( nCount == sizeof(keys) / sizeof(keys[0]));
 444
 445             // extract_max_key
 446             for ( int i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 447                 CPPUNIT_ASSERT( s.emplace( keys[i], keys[i] * c_nStep ));
 448
 449             nCount = 1;
 450             xp = s.extract_max_key( keyPrev );
 451             CPPUNIT_ASSERT( xp );
 452             nPrev = xp->nVal;
 453             CPPUNIT_CHECK_EX( keyPrev == sizeof(keys) / sizeof(keys[0]) - 1,
 454                 "Expected=" << sizeof(keys) / sizeof(keys[0]) - 1 << " real=" << keyPrev );
 455             CPPUNIT_CHECK_EX( nPrev == c_nStep * (sizeof(keys) / sizeof(keys[0]) - 1),
 456                 "Expected=" << c_nStep * (sizeof(keys) / sizeof(keys[0]) - 1) << " real=" << nPrev );
 457             while ( !s.empty() ) {
 458                 xp = s.extract_max_key( key );
 459                 CPPUNIT_ASSERT( xp );
 460                 CPPUNIT_CHECK_EX( key == keyPrev - 1, "Expected=" << keyPrev - 1 << " real=" << key );
 461                 CPPUNIT_CHECK_EX( nPrev - c_nStep == xp->nVal, "Expected=" << nPrev - c_nStep << " real=" << xp->nVal );
 462                 nPrev = xp->nVal;
 463                 --keyPrev;
 464                 ++nCount;
 465             }
 466             CPPUNIT_CHECK( nCount == sizeof(keys) / sizeof(keys[0]));
 467
 468             // extract
 469             for ( int i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 470                 CPPUNIT_ASSERT( s.emplace( keys[i], keys[i] * c_nStep ));
 471
 472             for ( int i = 0; i < sizeof( keys ) / sizeof( keys[0] ); ++i ) {
 473                 xp = s.extract(keys[i]);
 474                 CPPUNIT_CHECK_EX( xp->nVal == keys[i] * c_nStep, "Expected value=" << keys[i] * c_nStep << " real=" << xp->nVal );
 475             }
 476             CPPUNIT_ASSERT(s.empty());
 477
 478
 479             // extract_with
 480             for ( int i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i )
 481                 CPPUNIT_ASSERT( s.emplace( keys[i], keys[i] * c_nStep ));
 482
 483             for ( int i = 0; i < sizeof( keys ) / sizeof( keys[0] ); ++i ) {
 484                 xp = s.extract_with( wrapped_int(keys[i]), wrapped_less());
 485                 CPPUNIT_CHECK_EX( xp->nVal == keys[i] * c_nStep, "Expected value=" << keys[i] * c_nStep << " real=" << xp->nVal );
 486             }
 487             CPPUNIT_ASSERT(s.empty());
 488         }
 489
 490         template <class Set, class PrintStat>
 491         void test()
 492         {
 493             typedef Set set_type;
 494
 495             set_type s;
 496
 497             test_with( s );
 498
 499             s.clear();
 500             CPPUNIT_ASSERT( s.empty() );
 501             CPPUNIT_ASSERT( check_size( s, 0 ) );
 502
 503
 504
 505             PrintStat()(s);
 506         }
 507
 508
 509         void BronsonAVLTree_rcu_gpb_less();
 510         void BronsonAVLTree_rcu_gpb_less_stat();
 511         void BronsonAVLTree_rcu_gpb_cmp();
 512         void BronsonAVLTree_rcu_gpb_cmp_stat();
 513         void BronsonAVLTree_rcu_gpb_cmpless();
 514         void BronsonAVLTree_rcu_gpb_less_ic();
 515         void BronsonAVLTree_rcu_gpb_cmp_ic();
 516         void BronsonAVLTree_rcu_gpb_cmp_ic_stat();
 517         void BronsonAVLTree_rcu_gpb_cmp_ic_stat_yield();
 518         void BronsonAVLTree_rcu_gpb_less_relaxed_insert();
 519         void BronsonAVLTree_rcu_gpb_less_relaxed_insert_stat();
 520         void BronsonAVLTree_rcu_gpb_pool_monitor_less();
 521         void BronsonAVLTree_rcu_gpb_pool_monitor_less_stat();
 522         void BronsonAVLTree_rcu_gpb_pool_monitor_cmp_ic_stat();
 523         void BronsonAVLTree_rcu_gpb_pool_monitor_cmp_ic_stat_yield();
 524         void BronsonAVLTree_rcu_gpb_pool_monitor_less_relaxed_insert();
 525         void BronsonAVLTree_rcu_gpb_pool_monitor_less_relaxed_insert_stat();
 526
 527         CPPUNIT_TEST_SUITE( BronsonAVLTreeHdrTest )
 528             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_less )
 529             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_less_stat )
 530             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_cmp )
 531             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_cmp_stat )
 532             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_cmpless )
 533             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_less_ic )
 534             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_cmp_ic )
 535             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_cmp_ic_stat )
 536             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_cmp_ic_stat_yield )
 537             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_less_relaxed_insert )
 538             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_less_relaxed_insert_stat )
 539             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_pool_monitor_less )
 540             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_pool_monitor_less_stat )
 541             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_pool_monitor_cmp_ic_stat )
 542             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_pool_monitor_cmp_ic_stat_yield )
 543             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_pool_monitor_less_relaxed_insert )
 544             CPPUNIT_TEST( BronsonAVLTree_rcu_gpb_pool_monitor_less_relaxed_insert_stat )
 545         CPPUNIT_TEST_SUITE_END()
 546     };
 547 } // namespace tree
 548
 549 #endif // #ifndef CDSTEST_HDR_BRONSON_AVLTREE_MAP_H