tests/test-hdr/tree/hdr_ellenbintree_map.h

   1 //$$CDS-header$$
   2
   3 #ifndef CDSHDRTEST_ELLENBINTREE_MAP_H
   4 #define CDSHDRTEST_ELLENBINTREE_MAP_H
   5
   6 #include "cppunit/cppunit_proxy.h"
   7 #include "size_check.h"
   8 #include <cds/ref.h>
   9 #include <algorithm>
  10
  11 namespace tree {
  12     using misc::check_size;
  13
  14     class EllenBinTreeMapHdrTest: 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             size_t  nFindConstFuncCall;
  26
  27             stat_data()
  28                 : nInsertFuncCall(0)
  29                 , nEnsureExistFuncCall(0)
  30                 , nEnsureNewFuncCall(0)
  31                 , nEraseFuncCall(0)
  32                 , nFindFuncCall(0)
  33                 , nFindConstFuncCall(0)
  34             {}
  35         };
  36
  37         struct value_type: public stat_data
  38         {
  39             int         nVal;
  40
  41             value_type()
  42                 : nVal(0)
  43             {}
  44
  45             value_type( int v )
  46                 : nVal( v )
  47             {}
  48
  49             value_type( value_type const& v )
  50                 : nVal( v.nVal )
  51             {}
  52
  53             value_type( value_type&& v )
  54                 : nVal( v.nVal )
  55             {}
  56
  57             value_type& operator=( int n )
  58             {
  59                 nVal = n;
  60                 return *this;
  61             }
  62
  63             value_type& operator=( value_type const& v )
  64             {
  65                 nVal = v.nVal;
  66                 return *this;
  67             }
  68         };
  69
  70         typedef std::pair<key_type const, value_type> pair_type;
  71
  72         struct less {
  73             bool operator()( int k1, int k2 ) const
  74             {
  75                 return k1 < k2;
  76             }
  77         };
  78
  79         struct compare {
  80             int cmp( int k1, int k2 ) const
  81             {
  82                 return k1 < k2 ? -1 : (k1 > k2 ? 1 : 0);
  83             }
  84             int operator()( int k1, int k2 ) const
  85             {
  86                 return cmp( k1, k2 );
  87             }
  88         };
  89
  90         struct wrapped_int {
  91             int  nKey;
  92
  93             wrapped_int( int n )
  94                 : nKey(n)
  95             {}
  96         };
  97
  98         struct wrapped_less
  99         {
 100             bool operator()( wrapped_int const& w, int n ) const
 101             {
 102                 return w.nKey < n;
 103             }
 104             bool operator()( int n, wrapped_int const& w ) const
 105             {
 106                 return n < w.nKey;
 107             }
 108             /*
 109             template <typename T>
 110             bool operator()( wrapped_int const& w, T const& v ) const
 111             {
 112                 return w.nKey < v.nKey;
 113             }
 114             template <typename T>
 115             bool operator()( T const& v, wrapped_int const& w ) const
 116             {
 117                 return v.nKey < w.nKey;
 118             }
 119             */
 120         };
 121
 122     protected:
 123         template <typename Map>
 124         struct insert_functor
 125         {
 126             typedef typename Map::value_type pair_type;
 127
 128             // insert ftor
 129             void operator()( pair_type& item )
 130             {
 131                 item.second.nVal = item.first * 3;
 132             }
 133
 134             // ensure ftor
 135             void operator()( bool bNew, pair_type& item )
 136             {
 137                 if ( bNew )
 138                     item.second.nVal = item.first * 2;
 139                 else
 140                     item.second.nVal = item.first * 5;
 141             }
 142         };
 143
 144         struct check_value {
 145             int     m_nExpected;
 146
 147             check_value( int nExpected )
 148                 : m_nExpected( nExpected )
 149             {}
 150
 151             template <typename T>
 152             void operator ()( T& pair )
 153             {
 154                 CPPUNIT_ASSERT_CURRENT( pair.second.nVal == m_nExpected );
 155             }
 156             template <typename T, typename Q>
 157             void operator ()( T& pair, Q )
 158             {
 159                 CPPUNIT_ASSERT_CURRENT( pair.second.nVal == m_nExpected );
 160             }
 161         };
 162
 163         struct extract_functor
 164         {
 165             int *   m_pVal;
 166             void operator()( pair_type const& val )
 167             {
 168                 *m_pVal = val.second.nVal;
 169             }
 170         };
 171
 172     protected:
 173         static const size_t c_nItemCount = 10000;
 174
 175         class data_array
 176         {
 177             int *     pFirst;
 178             int *     pLast;
 179
 180         public:
 181             data_array()
 182                 : pFirst( new int[c_nItemCount] )
 183                 , pLast( pFirst + c_nItemCount )
 184             {
 185                 int i = 0;
 186                 for ( int * p = pFirst; p != pLast; ++p, ++i )
 187                     *p = i;
 188
 189                 std::random_shuffle( pFirst, pLast );
 190             }
 191
 192             ~data_array()
 193             {
 194                 delete [] pFirst;
 195             }
 196
 197             int operator[]( size_t i ) const
 198             {
 199                 assert( i < size_t(pLast - pFirst) );
 200                 return pFirst[i];
 201             }
 202         };
 203
 204         struct extract_functor2
 205         {
 206             int nKey;
 207
 208             template <typename Q>
 209             void operator()( Q&, pair_type& v )
 210             {
 211                 nKey = v.first;
 212             }
 213         };
 214
 215
 216     protected:
 217
 218         template <class Map>
 219         void test_with( Map& m )
 220         {
 221             std::pair<bool, bool> ensureResult;
 222
 223             // insert
 224             CPPUNIT_ASSERT( m.empty() );
 225             CPPUNIT_ASSERT( check_size( m, 0 ));
 226             CPPUNIT_ASSERT( !m.find(25) );
 227             CPPUNIT_ASSERT( m.insert( 25 ) )    ;   // value = 0
 228             CPPUNIT_ASSERT( m.find(25) );
 229             CPPUNIT_ASSERT( !m.empty() );
 230             CPPUNIT_ASSERT( check_size( m, 1 ));
 231             CPPUNIT_ASSERT( m.find(25) );
 232
 233             CPPUNIT_ASSERT( !m.insert( 25 ) );
 234             CPPUNIT_ASSERT( !m.empty() );
 235             CPPUNIT_ASSERT( check_size( m, 1 ));
 236
 237             CPPUNIT_ASSERT( !m.find_with(10, less()) );
 238             CPPUNIT_ASSERT( m.insert( 10, 10 ) );
 239             CPPUNIT_ASSERT( !m.empty() );
 240             CPPUNIT_ASSERT( check_size( m, 2 ));
 241             CPPUNIT_ASSERT( m.find_with(10, less()) );
 242
 243             CPPUNIT_ASSERT( !m.insert( 10, 20 ) );
 244             CPPUNIT_ASSERT( !m.empty() );
 245             CPPUNIT_ASSERT( check_size( m, 2 ));
 246
 247             CPPUNIT_ASSERT( !m.find(30) );
 248             CPPUNIT_ASSERT( m.insert_key( 30, insert_functor<Map>() ) )    ; // value = 90
 249             CPPUNIT_ASSERT( !m.empty() );
 250             CPPUNIT_ASSERT( check_size( m, 3 ));
 251             CPPUNIT_ASSERT( m.find(30) );
 252
 253             CPPUNIT_ASSERT( !m.insert_key( 10, insert_functor<Map>() ) );
 254             CPPUNIT_ASSERT( !m.insert_key( 25, insert_functor<Map>() ) );
 255             CPPUNIT_ASSERT( !m.insert_key( 30, insert_functor<Map>() ) );
 256
 257             // ensure (new key)
 258             CPPUNIT_ASSERT( !m.find(27) );
 259             ensureResult = m.ensure( 27, insert_functor<Map>() ) ;   // value = 54
 260             CPPUNIT_ASSERT( ensureResult.first );
 261             CPPUNIT_ASSERT( ensureResult.second );
 262             CPPUNIT_ASSERT( m.find(27) );
 263
 264             // find test
 265             check_value chk(10);
 266             CPPUNIT_ASSERT( m.find( 10, cds::ref(chk) ));
 267             chk.m_nExpected = 0;
 268             CPPUNIT_ASSERT( m.find_with( 25, less(), boost::ref(chk) ));
 269             chk.m_nExpected = 90;
 270             CPPUNIT_ASSERT( m.find( 30, boost::ref(chk) ));
 271             chk.m_nExpected = 54;
 272             CPPUNIT_ASSERT( m.find( 27, boost::ref(chk) ));
 273
 274             ensureResult = m.ensure( 10, insert_functor<Map>() ) ;   // value = 50
 275             CPPUNIT_ASSERT( ensureResult.first );
 276             CPPUNIT_ASSERT( !ensureResult.second );
 277             chk.m_nExpected = 50;
 278             CPPUNIT_ASSERT( m.find( 10, boost::ref(chk) ));
 279
 280             // erase test
 281             CPPUNIT_ASSERT( !m.find(100) );
 282             CPPUNIT_ASSERT( !m.erase( 100 )) ;  // not found
 283
 284             CPPUNIT_ASSERT( m.find(25) );
 285             CPPUNIT_ASSERT( check_size( m, 4 ));
 286             CPPUNIT_ASSERT( m.erase( 25 ));
 287             CPPUNIT_ASSERT( !m.empty() );
 288             CPPUNIT_ASSERT( check_size( m, 3 ));
 289             CPPUNIT_ASSERT( !m.find(25) );
 290             CPPUNIT_ASSERT( !m.erase( 25 ));
 291
 292             CPPUNIT_ASSERT( !m.find(258) );
 293             CPPUNIT_ASSERT( m.insert(258))
 294             CPPUNIT_ASSERT( check_size( m, 4 ));
 295             CPPUNIT_ASSERT( m.find_with(258, less()) );
 296             CPPUNIT_ASSERT( m.erase_with( 258, less() ));
 297             CPPUNIT_ASSERT( !m.empty() );
 298             CPPUNIT_ASSERT( check_size( m, 3 ));
 299             CPPUNIT_ASSERT( !m.find(258) );
 300             CPPUNIT_ASSERT( !m.erase_with( 258, less() ));
 301
 302             int nVal;
 303             extract_functor ext;
 304             ext.m_pVal = &nVal;
 305
 306             CPPUNIT_ASSERT( !m.find(29) );
 307             CPPUNIT_ASSERT( m.insert(29, 290));
 308             CPPUNIT_ASSERT( check_size( m, 4 ));
 309             CPPUNIT_ASSERT( m.erase_with( 29, less(), boost::ref(ext)));
 310             CPPUNIT_ASSERT( !m.empty() );
 311             CPPUNIT_ASSERT( check_size( m, 3 ));
 312             CPPUNIT_ASSERT( nVal == 290 );
 313             nVal = -1;
 314             CPPUNIT_ASSERT( !m.erase_with( 29, less(), boost::ref(ext)));
 315             CPPUNIT_ASSERT( nVal == -1 );
 316
 317             CPPUNIT_ASSERT( m.erase( 30, boost::ref(ext)));
 318             CPPUNIT_ASSERT( !m.empty() );
 319             CPPUNIT_ASSERT( check_size( m, 2 ));
 320             CPPUNIT_ASSERT( nVal == 90 );
 321             nVal = -1;
 322             CPPUNIT_ASSERT( !m.erase( 30, boost::ref(ext)));
 323             CPPUNIT_ASSERT( nVal == -1 );
 324
 325             m.clear();
 326             CPPUNIT_ASSERT( m.empty() );
 327             CPPUNIT_ASSERT( check_size( m, 0 ));
 328
 329 #       ifdef CDS_EMPLACE_SUPPORT
 330             // emplace test
 331             CPPUNIT_ASSERT( m.emplace(126) ) ; // key = 126, val = 0
 332             CPPUNIT_ASSERT( m.emplace(137, 731))    ;   // key = 137, val = 731
 333             CPPUNIT_ASSERT( m.emplace( 149, value_type(941) ))   ;   // key = 149, val = 941
 334
 335             CPPUNIT_ASSERT( !m.empty() );
 336             CPPUNIT_ASSERT( check_size( m, 3 ));
 337
 338             chk.m_nExpected = 0;
 339             CPPUNIT_ASSERT( m.find( 126, cds::ref(chk) ));
 340             chk.m_nExpected = 731;
 341             CPPUNIT_ASSERT( m.find_with( 137, less(), cds::ref(chk) ));
 342             chk.m_nExpected = 941;
 343             CPPUNIT_ASSERT( m.find( 149, cds::ref(chk) ));
 344
 345             CPPUNIT_ASSERT( !m.emplace(126, 621)) ; // already in map
 346             chk.m_nExpected = 0;
 347             CPPUNIT_ASSERT( m.find( 126, cds::ref(chk) ));
 348             CPPUNIT_ASSERT( !m.empty() );
 349             CPPUNIT_ASSERT( check_size( m, 3 ));
 350
 351             m.clear();
 352             CPPUNIT_ASSERT( m.empty() );
 353             CPPUNIT_ASSERT( check_size( m, 0 ));
 354 #       endif
 355         }
 356
 357         template <typename Map>
 358         void fill_map( Map& s, data_array& a )
 359         {
 360             CPPUNIT_ASSERT( s.empty() );
 361             for ( size_t i = 0; i < c_nItemCount; ++i ) {
 362                 CPPUNIT_ASSERT( s.insert( a[i] ));
 363             }
 364             CPPUNIT_ASSERT( !s.empty() );
 365             CPPUNIT_ASSERT( check_size( s, c_nItemCount ));
 366         }
 367
 368         template <class Map, class PrintStat>
 369         void test()
 370         {
 371             typedef Map map_type;
 372
 373             map_type m;
 374
 375             test_with( m );
 376
 377             m.clear();
 378             CPPUNIT_ASSERT( m.empty() );
 379             CPPUNIT_ASSERT( check_size( m, 0 ));
 380
 381             // extract min/max
 382             {
 383                 typename map_type::guarded_ptr gp;
 384
 385                 data_array arr;
 386                 fill_map( m, arr );
 387
 388                 int i = 0;
 389                 std::pair<key_type, value_type> v;
 390                 while ( !m.empty() ) {
 391                     CPPUNIT_ASSERT( m.extract_min( gp ) );
 392                     CPPUNIT_ASSERT( !gp.empty());
 393                     CPPUNIT_ASSERT( gp->first == i );
 394                     ++i;
 395                     gp.release();
 396                 }
 397                 CPPUNIT_ASSERT( m.empty() );
 398                 CPPUNIT_ASSERT( check_size( m, 0 ));
 399
 400
 401                 fill_map( m, arr );
 402                 i = (int) c_nItemCount - 1;
 403                 while ( !m.empty() ) {
 404                     CPPUNIT_ASSERT( m.extract_max( gp ) );
 405                     CPPUNIT_ASSERT( !gp.empty());
 406                     CPPUNIT_ASSERT( gp->first == i );
 407                     --i;
 408                     gp.release();
 409                 }
 410                 CPPUNIT_ASSERT( m.empty() );
 411                 CPPUNIT_ASSERT( check_size( m, 0 ));
 412
 413                 fill_map( m, arr );
 414                 for ( int i = 0; i < static_cast<int>( c_nItemCount ); ++i ) {
 415                     int nKey = arr[i];
 416                     CPPUNIT_ASSERT( m.get( gp, nKey ));
 417                     CPPUNIT_ASSERT( !gp.empty());
 418                     CPPUNIT_CHECK( gp->first == nKey );
 419
 420                     gp.release();
 421                     CPPUNIT_ASSERT( m.extract( gp, nKey ));
 422                     CPPUNIT_ASSERT( !gp.empty());
 423                     CPPUNIT_CHECK( gp->first == nKey );
 424
 425                     gp.release();
 426                     CPPUNIT_CHECK( !m.get( gp, nKey ));
 427                     CPPUNIT_CHECK( gp.empty());
 428                     CPPUNIT_CHECK( !m.extract( gp, nKey ));
 429                     CPPUNIT_CHECK( gp.empty());
 430                 }
 431                 CPPUNIT_ASSERT( m.empty() );
 432                 CPPUNIT_ASSERT( check_size( m, 0 ));
 433
 434                 fill_map( m, arr );
 435                 for ( int i = 0; i < static_cast<int>( c_nItemCount ); ++i ) {
 436                     int nKey = arr[i];
 437                     CPPUNIT_ASSERT( m.get_with( gp, wrapped_int(nKey), wrapped_less() ));
 438                     CPPUNIT_ASSERT( !gp.empty());
 439                     CPPUNIT_CHECK( gp->first == nKey );
 440
 441                     gp.release();
 442                     CPPUNIT_ASSERT( m.extract_with( gp, wrapped_int(nKey), wrapped_less() ));
 443                     CPPUNIT_ASSERT( !gp.empty());
 444                     CPPUNIT_CHECK( gp->first == nKey );
 445
 446                     gp.release();
 447                     CPPUNIT_CHECK( !m.get_with( gp, wrapped_int(nKey), wrapped_less() ));
 448                     CPPUNIT_CHECK( gp.empty());
 449                     CPPUNIT_CHECK( !m.extract_with( gp, wrapped_int(nKey), wrapped_less() ));
 450                     CPPUNIT_CHECK( gp.empty());
 451                 }
 452
 453                 CPPUNIT_ASSERT( m.empty() );
 454                 CPPUNIT_ASSERT( check_size( m, 0 ));
 455             }
 456
 457             PrintStat()( m );
 458         }
 459
 460         template <class Map, class PrintStat>
 461         void test_rcu()
 462         {
 463             typedef Map map_type;
 464
 465             map_type m;
 466
 467             test_with( m );
 468
 469             m.clear();
 470             CPPUNIT_ASSERT( m.empty() );
 471             CPPUNIT_ASSERT( check_size( m, 0 ));
 472
 473             // extract min/max
 474             {
 475                 typename map_type::exempt_ptr ep;
 476                 data_array arr;
 477                 fill_map( m, arr );
 478
 479                 int i = 0;
 480                 while ( !m.empty() ) {
 481                     CPPUNIT_ASSERT( m.extract_min( ep ) );
 482                     CPPUNIT_ASSERT( !ep.empty());
 483                     CPPUNIT_ASSERT(ep->first == i );
 484                     ++i;
 485                     ep.release();
 486                 }
 487                 CPPUNIT_ASSERT( m.empty() );
 488                 CPPUNIT_ASSERT( check_size( m, 0 ));
 489                 CPPUNIT_ASSERT( !m.extract_min( ep ) );
 490                 CPPUNIT_ASSERT( ep.empty());
 491
 492                 fill_map( m, arr );
 493                 i = (int) c_nItemCount - 1;
 494                 while ( !m.empty() ) {
 495                     CPPUNIT_ASSERT( m.extract_max( ep ) );
 496                     CPPUNIT_ASSERT( !ep.empty());
 497                     CPPUNIT_ASSERT( ep->first == i );
 498                     --i;
 499                     ep.release();
 500                 }
 501                 CPPUNIT_ASSERT( m.empty() );
 502                 CPPUNIT_ASSERT( check_size( m, 0 ));
 503                 CPPUNIT_ASSERT( !m.extract_max( ep ) );
 504                 CPPUNIT_ASSERT( ep.empty());
 505
 506                 fill_map( m, arr );
 507                 for ( size_t i = 0; i < c_nItemCount; ++i ) {
 508                     int nKey = arr[i];
 509                     {
 510                         typename map_type::rcu_lock l;
 511                         typename map_type::value_type * pVal = m.get(nKey);
 512                         CPPUNIT_ASSERT( pVal != nullptr );
 513                         CPPUNIT_CHECK( pVal->first == nKey);
 514                     }
 515                     CPPUNIT_ASSERT( m.extract( ep, nKey ));
 516                     CPPUNIT_ASSERT( !ep.empty());
 517                     CPPUNIT_CHECK( ep->first == nKey);
 518                     ep.release();
 519
 520                     CPPUNIT_ASSERT( !m.extract( ep, nKey ));
 521                     CPPUNIT_ASSERT( ep.empty());
 522                     {
 523                         typename map_type::rcu_lock l;
 524                         CPPUNIT_CHECK( !m.get(nKey));
 525                     }
 526                 }
 527                 CPPUNIT_ASSERT( m.empty() );
 528                 CPPUNIT_ASSERT( check_size( m, 0 ));
 529
 530                 fill_map( m, arr );
 531                 for ( size_t i = 0; i < c_nItemCount; ++i ) {
 532                     int nKey = arr[i];
 533                     {
 534                         typename map_type::rcu_lock l;
 535                         typename map_type::value_type * pVal = m.get_with(wrapped_int(nKey), wrapped_less());
 536                         CPPUNIT_ASSERT( pVal != nullptr );
 537                         CPPUNIT_CHECK( pVal->first == nKey);
 538                     }
 539                     CPPUNIT_ASSERT( m.extract_with( ep, wrapped_int(nKey), wrapped_less() ));
 540                     CPPUNIT_ASSERT( !ep.empty());
 541                     CPPUNIT_CHECK( ep->first == nKey);
 542                     ep.release();
 543
 544                     CPPUNIT_ASSERT( !m.extract_with( ep, wrapped_int(nKey), wrapped_less() ));
 545                     CPPUNIT_ASSERT( ep.empty());
 546                     {
 547                         typename map_type::rcu_lock l;
 548                         CPPUNIT_CHECK( !m.get_with(wrapped_int(nKey), wrapped_less()));
 549                     }
 550                 }
 551                 CPPUNIT_ASSERT( m.empty() );
 552                 CPPUNIT_ASSERT( check_size( m, 0 ));
 553             }
 554
 555             PrintStat()( m );
 556         }
 557
 558         void EllenBinTree_rcu_gpi_less();
 559         void EllenBinTree_rcu_gpi_cmp();
 560         void EllenBinTree_rcu_gpi_cmpless();
 561         void EllenBinTree_rcu_gpi_less_ic();
 562         void EllenBinTree_rcu_gpi_cmp_ic();
 563         void EllenBinTree_rcu_gpi_less_stat();
 564         void EllenBinTree_rcu_gpi_cmp_ic_stat();
 565         void EllenBinTree_rcu_gpi_less_pool();
 566         void EllenBinTree_rcu_gpi_less_pool_ic_stat();
 567
 568         void EllenBinTree_hp_less();
 569         void EllenBinTree_hp_cmp();
 570         void EllenBinTree_hp_cmpless();
 571         void EllenBinTree_hp_less_ic();
 572         void EllenBinTree_hp_cmp_ic();
 573         void EllenBinTree_hp_less_stat();
 574         void EllenBinTree_hp_cmp_ic_stat();
 575         void EllenBinTree_hp_less_pool();
 576         void EllenBinTree_hp_less_pool_ic_stat();
 577
 578         void EllenBinTree_ptb_less();
 579         void EllenBinTree_ptb_cmp();
 580         void EllenBinTree_ptb_cmpless();
 581         void EllenBinTree_ptb_less_ic();
 582         void EllenBinTree_ptb_cmp_ic();
 583         void EllenBinTree_ptb_less_stat();
 584         void EllenBinTree_ptb_cmp_ic_stat();
 585         void EllenBinTree_ptb_less_pool();
 586         void EllenBinTree_ptb_less_pool_ic_stat();
 587
 588         void EllenBinTree_rcu_gpb_less();
 589         void EllenBinTree_rcu_gpb_cmp();
 590         void EllenBinTree_rcu_gpb_cmpless();
 591         void EllenBinTree_rcu_gpb_less_ic();
 592         void EllenBinTree_rcu_gpb_cmp_ic();
 593         void EllenBinTree_rcu_gpb_less_stat();
 594         void EllenBinTree_rcu_gpb_cmp_ic_stat();
 595         void EllenBinTree_rcu_gpb_less_pool();
 596         void EllenBinTree_rcu_gpb_less_pool_ic_stat();
 597
 598         void EllenBinTree_rcu_gpt_less();
 599         void EllenBinTree_rcu_gpt_cmp();
 600         void EllenBinTree_rcu_gpt_cmpless();
 601         void EllenBinTree_rcu_gpt_less_ic();
 602         void EllenBinTree_rcu_gpt_cmp_ic();
 603         void EllenBinTree_rcu_gpt_less_stat();
 604         void EllenBinTree_rcu_gpt_cmp_ic_stat();
 605         void EllenBinTree_rcu_gpt_less_pool();
 606         void EllenBinTree_rcu_gpt_less_pool_ic_stat();
 607
 608         void EllenBinTree_rcu_shb_less();
 609         void EllenBinTree_rcu_shb_cmp();
 610         void EllenBinTree_rcu_shb_cmpless();
 611         void EllenBinTree_rcu_shb_less_ic();
 612         void EllenBinTree_rcu_shb_cmp_ic();
 613         void EllenBinTree_rcu_shb_less_stat();
 614         void EllenBinTree_rcu_shb_cmp_ic_stat();
 615         void EllenBinTree_rcu_shb_less_pool();
 616         void EllenBinTree_rcu_shb_less_pool_ic_stat();
 617
 618         void EllenBinTree_rcu_sht_less();
 619         void EllenBinTree_rcu_sht_cmp();
 620         void EllenBinTree_rcu_sht_cmpless();
 621         void EllenBinTree_rcu_sht_less_ic();
 622         void EllenBinTree_rcu_sht_cmp_ic();
 623         void EllenBinTree_rcu_sht_less_stat();
 624         void EllenBinTree_rcu_sht_cmp_ic_stat();
 625         void EllenBinTree_rcu_sht_less_pool();
 626         void EllenBinTree_rcu_sht_less_pool_ic_stat();
 627
 628         CPPUNIT_TEST_SUITE(EllenBinTreeMapHdrTest)
 629             CPPUNIT_TEST(EllenBinTree_hp_less)
 630             CPPUNIT_TEST(EllenBinTree_hp_cmp)
 631             CPPUNIT_TEST(EllenBinTree_hp_less_stat)
 632             CPPUNIT_TEST(EllenBinTree_hp_cmpless)
 633             CPPUNIT_TEST(EllenBinTree_hp_less_ic)
 634             CPPUNIT_TEST(EllenBinTree_hp_cmp_ic)
 635             CPPUNIT_TEST(EllenBinTree_hp_cmp_ic_stat)
 636             CPPUNIT_TEST(EllenBinTree_hp_less_pool)
 637             CPPUNIT_TEST(EllenBinTree_hp_less_pool_ic_stat)
 638
 639             CPPUNIT_TEST(EllenBinTree_ptb_less)
 640             CPPUNIT_TEST(EllenBinTree_ptb_cmp)
 641             CPPUNIT_TEST(EllenBinTree_ptb_less_stat)
 642             CPPUNIT_TEST(EllenBinTree_ptb_cmpless)
 643             CPPUNIT_TEST(EllenBinTree_ptb_less_ic)
 644             CPPUNIT_TEST(EllenBinTree_ptb_cmp_ic)
 645             CPPUNIT_TEST(EllenBinTree_ptb_cmp_ic_stat)
 646             CPPUNIT_TEST(EllenBinTree_ptb_less_pool)
 647             CPPUNIT_TEST(EllenBinTree_ptb_less_pool_ic_stat)
 648
 649             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less)
 650             CPPUNIT_TEST(EllenBinTree_rcu_gpi_cmp)
 651             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less_stat)
 652             CPPUNIT_TEST(EllenBinTree_rcu_gpi_cmpless)
 653             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less_ic)
 654             CPPUNIT_TEST(EllenBinTree_rcu_gpi_cmp_ic)
 655             CPPUNIT_TEST(EllenBinTree_rcu_gpi_cmp_ic_stat)
 656             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less_pool)
 657             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less_pool_ic_stat)
 658
 659             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less)
 660             CPPUNIT_TEST(EllenBinTree_rcu_gpb_cmp)
 661             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less_stat)
 662             CPPUNIT_TEST(EllenBinTree_rcu_gpb_cmpless)
 663             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less_ic)
 664             CPPUNIT_TEST(EllenBinTree_rcu_gpb_cmp_ic)
 665             CPPUNIT_TEST(EllenBinTree_rcu_gpb_cmp_ic_stat)
 666             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less_pool)
 667             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less_pool_ic_stat)
 668
 669             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less)
 670             CPPUNIT_TEST(EllenBinTree_rcu_gpt_cmp)
 671             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less_stat)
 672             CPPUNIT_TEST(EllenBinTree_rcu_gpt_cmpless)
 673             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less_ic)
 674             CPPUNIT_TEST(EllenBinTree_rcu_gpt_cmp_ic)
 675             CPPUNIT_TEST(EllenBinTree_rcu_gpt_cmp_ic_stat)
 676             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less_pool)
 677             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less_pool_ic_stat)
 678
 679             CPPUNIT_TEST(EllenBinTree_rcu_shb_less)
 680             CPPUNIT_TEST(EllenBinTree_rcu_shb_cmp)
 681             CPPUNIT_TEST(EllenBinTree_rcu_shb_less_stat)
 682             CPPUNIT_TEST(EllenBinTree_rcu_shb_cmpless)
 683             CPPUNIT_TEST(EllenBinTree_rcu_shb_less_ic)
 684             CPPUNIT_TEST(EllenBinTree_rcu_shb_cmp_ic)
 685             CPPUNIT_TEST(EllenBinTree_rcu_shb_cmp_ic_stat)
 686             CPPUNIT_TEST(EllenBinTree_rcu_shb_less_pool)
 687             CPPUNIT_TEST(EllenBinTree_rcu_shb_less_pool_ic_stat)
 688
 689             CPPUNIT_TEST(EllenBinTree_rcu_sht_less)
 690             CPPUNIT_TEST(EllenBinTree_rcu_sht_cmp)
 691             CPPUNIT_TEST(EllenBinTree_rcu_sht_less_stat)
 692             CPPUNIT_TEST(EllenBinTree_rcu_sht_cmpless)
 693             CPPUNIT_TEST(EllenBinTree_rcu_sht_less_ic)
 694             CPPUNIT_TEST(EllenBinTree_rcu_sht_cmp_ic)
 695             CPPUNIT_TEST(EllenBinTree_rcu_sht_cmp_ic_stat)
 696             CPPUNIT_TEST(EllenBinTree_rcu_sht_less_pool)
 697             CPPUNIT_TEST(EllenBinTree_rcu_sht_less_pool_ic_stat)
 698
 699             CPPUNIT_TEST_SUITE_END()
 700
 701     };
 702 } // namespace tree
 703
 704 #endif // #ifndef CDSHDRTEST_ELLENBINTREE_MAP_H