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 <functional>   // ref
   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_with( 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_with( 10, insert_functor<Map>() ) );
 254             CPPUNIT_ASSERT( !m.insert_with( 25, insert_functor<Map>() ) );
 255             CPPUNIT_ASSERT( !m.insert_with( 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, std::ref(chk) ));
 267             chk.m_nExpected = 0;
 268             CPPUNIT_ASSERT( m.find_with( 25, less(), std::ref( chk ) ) );
 269             chk.m_nExpected = 90;
 270             CPPUNIT_ASSERT( m.find( 30, std::ref( chk ) ) );
 271             chk.m_nExpected = 54;
 272             CPPUNIT_ASSERT( m.find( 27, std::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, std::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(), std::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(), std::ref( ext ) ) );
 315             CPPUNIT_ASSERT( nVal == -1 );
 316
 317             CPPUNIT_ASSERT( m.erase( 30, std::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, std::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             // emplace test
 330             CPPUNIT_ASSERT( m.emplace(126) ) ; // key = 126, val = 0
 331             CPPUNIT_ASSERT( m.emplace(137, 731))    ;   // key = 137, val = 731
 332             CPPUNIT_ASSERT( m.emplace( 149, value_type(941) ))   ;   // key = 149, val = 941
 333
 334             CPPUNIT_ASSERT( !m.empty() );
 335             CPPUNIT_ASSERT( check_size( m, 3 ));
 336
 337             chk.m_nExpected = 0;
 338             CPPUNIT_ASSERT( m.find( 126, std::ref(chk) ));
 339             chk.m_nExpected = 731;
 340             CPPUNIT_ASSERT( m.find_with( 137, less(), std::ref(chk) ));
 341             chk.m_nExpected = 941;
 342             CPPUNIT_ASSERT( m.find( 149, std::ref(chk) ));
 343
 344             CPPUNIT_ASSERT( !m.emplace(126, 621)) ; // already in map
 345             chk.m_nExpected = 0;
 346             CPPUNIT_ASSERT( m.find( 126, std::ref(chk) ));
 347             CPPUNIT_ASSERT( !m.empty() );
 348             CPPUNIT_ASSERT( check_size( m, 3 ));
 349
 350             m.clear();
 351             CPPUNIT_ASSERT( m.empty() );
 352             CPPUNIT_ASSERT( check_size( m, 0 ));
 353         }
 354
 355         template <typename Map>
 356         void fill_map( Map& s, data_array& a )
 357         {
 358             CPPUNIT_ASSERT( s.empty() );
 359             for ( size_t i = 0; i < c_nItemCount; ++i ) {
 360                 CPPUNIT_ASSERT( s.insert( a[i] ));
 361             }
 362             CPPUNIT_ASSERT( !s.empty() );
 363             CPPUNIT_ASSERT( check_size( s, c_nItemCount ));
 364         }
 365
 366         template <class Map, class PrintStat>
 367         void test()
 368         {
 369             typedef Map map_type;
 370
 371             map_type m;
 372
 373             test_with( m );
 374
 375             m.clear();
 376             CPPUNIT_ASSERT( m.empty() );
 377             CPPUNIT_ASSERT( check_size( m, 0 ));
 378
 379             // extract min/max
 380             {
 381                 typename map_type::guarded_ptr gp;
 382
 383                 data_array arr;
 384                 fill_map( m, arr );
 385
 386                 int i = 0;
 387                 std::pair<key_type, value_type> v;
 388                 while ( !m.empty() ) {
 389                     gp = m.extract_min();
 390                     CPPUNIT_ASSERT( gp );
 391                     CPPUNIT_ASSERT( !gp.empty());
 392                     CPPUNIT_ASSERT( gp->first == i );
 393                     ++i;
 394                 }
 395                 CPPUNIT_ASSERT( m.empty() );
 396                 CPPUNIT_ASSERT( check_size( m, 0 ));
 397
 398
 399                 fill_map( m, arr );
 400                 i = (int) c_nItemCount - 1;
 401                 while ( !m.empty() ) {
 402                     gp = m.extract_max();
 403                     CPPUNIT_ASSERT( gp );
 404                     CPPUNIT_ASSERT( !gp.empty());
 405                     CPPUNIT_ASSERT( gp->first == i );
 406                     --i;
 407                 }
 408                 CPPUNIT_ASSERT( m.empty() );
 409                 CPPUNIT_ASSERT( check_size( m, 0 ));
 410
 411                 fill_map( m, arr );
 412                 for ( int i = 0; i < static_cast<int>( c_nItemCount ); ++i ) {
 413                     int nKey = arr[i];
 414                     gp = m.get( nKey );
 415                     CPPUNIT_ASSERT( gp );
 416                     CPPUNIT_ASSERT( !gp.empty());
 417                     CPPUNIT_CHECK( gp->first == nKey );
 418
 419                     gp = m.extract( nKey );
 420                     CPPUNIT_ASSERT( gp );
 421                     CPPUNIT_ASSERT( !gp.empty());
 422                     CPPUNIT_CHECK( gp->first == nKey );
 423
 424                     gp = m.get( nKey );
 425                     CPPUNIT_CHECK( !gp );
 426                     CPPUNIT_CHECK( gp.empty());
 427                     CPPUNIT_CHECK( !m.extract( nKey ));
 428                     CPPUNIT_CHECK( gp.empty());
 429                 }
 430                 CPPUNIT_ASSERT( m.empty() );
 431                 CPPUNIT_ASSERT( check_size( m, 0 ));
 432
 433                 fill_map( m, arr );
 434                 for ( int i = 0; i < static_cast<int>( c_nItemCount ); ++i ) {
 435                     int nKey = arr[i];
 436                     gp = m.get_with( wrapped_int( nKey ), wrapped_less() );
 437                     CPPUNIT_ASSERT( gp );
 438                     CPPUNIT_ASSERT( !gp.empty());
 439                     CPPUNIT_CHECK( gp->first == nKey );
 440
 441                     gp = m.extract_with( wrapped_int( nKey ), wrapped_less() );
 442                     CPPUNIT_ASSERT( gp );
 443                     CPPUNIT_ASSERT( !gp.empty());
 444                     CPPUNIT_CHECK( gp->first == nKey );
 445
 446                     gp = m.get_with( wrapped_int( nKey ), wrapped_less() );
 447                     CPPUNIT_CHECK( !gp );
 448                     CPPUNIT_CHECK( gp.empty());
 449                     CPPUNIT_CHECK( !m.extract_with( 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                     ep = m.extract_min();
 482                     CPPUNIT_ASSERT( ep );
 483                     CPPUNIT_ASSERT( !ep.empty());
 484                     CPPUNIT_ASSERT(ep->first == i );
 485                     ++i;
 486                     //ep.release();
 487                 }
 488                 CPPUNIT_ASSERT( m.empty() );
 489                 CPPUNIT_ASSERT( check_size( m, 0 ));
 490                 ep = m.extract_min();
 491                 CPPUNIT_ASSERT( !ep );
 492                 CPPUNIT_ASSERT( ep.empty());
 493
 494                 fill_map( m, arr );
 495                 i = (int) c_nItemCount - 1;
 496                 while ( !m.empty() ) {
 497                     ep = m.extract_max();
 498                     CPPUNIT_ASSERT( ep );
 499                     CPPUNIT_ASSERT( !ep.empty());
 500                     CPPUNIT_ASSERT( ep->first == i );
 501                     --i;
 502                     //ep.release();
 503                 }
 504                 CPPUNIT_ASSERT( m.empty() );
 505                 CPPUNIT_ASSERT( check_size( m, 0 ));
 506                 ep = m.extract_max();
 507                 CPPUNIT_ASSERT( !ep );
 508                 CPPUNIT_ASSERT( ep.empty());
 509
 510                 fill_map( m, arr );
 511                 for ( size_t i = 0; i < c_nItemCount; ++i ) {
 512                     int nKey = arr[i];
 513                     {
 514                         typename map_type::rcu_lock l;
 515                         typename map_type::value_type * pVal = m.get(nKey);
 516                         CPPUNIT_ASSERT( pVal != nullptr );
 517                         CPPUNIT_CHECK( pVal->first == nKey);
 518                     }
 519                     ep = m.extract( nKey );
 520                     CPPUNIT_ASSERT( ep );
 521                     CPPUNIT_ASSERT( !ep.empty());
 522                     CPPUNIT_CHECK( ep->first == nKey);
 523                     //ep.release();
 524
 525                     ep = m.extract( nKey );
 526                     CPPUNIT_ASSERT( !ep );
 527                     CPPUNIT_ASSERT( ep.empty());
 528                     {
 529                         typename map_type::rcu_lock l;
 530                         CPPUNIT_CHECK( !m.get(nKey));
 531                     }
 532                 }
 533                 CPPUNIT_ASSERT( m.empty() );
 534                 CPPUNIT_ASSERT( check_size( m, 0 ));
 535
 536                 fill_map( m, arr );
 537                 for ( size_t i = 0; i < c_nItemCount; ++i ) {
 538                     int nKey = arr[i];
 539                     {
 540                         typename map_type::rcu_lock l;
 541                         typename map_type::value_type * pVal = m.get_with(wrapped_int(nKey), wrapped_less());
 542                         CPPUNIT_ASSERT( pVal != nullptr );
 543                         CPPUNIT_CHECK( pVal->first == nKey);
 544                     }
 545                     ep = m.extract_with( wrapped_int( nKey ), wrapped_less() );
 546                     CPPUNIT_ASSERT( ep );
 547                     CPPUNIT_ASSERT( !ep.empty());
 548                     CPPUNIT_CHECK( ep->first == nKey);
 549                     //ep.release();
 550
 551                     ep = m.extract_with( wrapped_int( nKey ), wrapped_less() );
 552                     CPPUNIT_ASSERT( !ep );
 553                     CPPUNIT_ASSERT( ep.empty());
 554                     {
 555                         typename map_type::rcu_lock l;
 556                         CPPUNIT_CHECK( !m.get_with(wrapped_int(nKey), wrapped_less()));
 557                     }
 558                 }
 559                 CPPUNIT_ASSERT( m.empty() );
 560                 CPPUNIT_ASSERT( check_size( m, 0 ));
 561             }
 562
 563             PrintStat()( m );
 564         }
 565
 566         void EllenBinTree_hp_less();
 567         void EllenBinTree_hp_cmp();
 568         void EllenBinTree_hp_cmpless();
 569         void EllenBinTree_hp_less_ic();
 570         void EllenBinTree_hp_cmp_ic();
 571         void EllenBinTree_hp_less_stat();
 572         void EllenBinTree_hp_cmp_ic_stat();
 573         void EllenBinTree_hp_cmp_ic_stat_yield();
 574         void EllenBinTree_hp_less_pool();
 575         void EllenBinTree_hp_less_pool_ic_stat();
 576
 577         void EllenBinTree_dhp_less();
 578         void EllenBinTree_dhp_cmp();
 579         void EllenBinTree_dhp_cmpless();
 580         void EllenBinTree_dhp_less_ic();
 581         void EllenBinTree_dhp_cmp_ic();
 582         void EllenBinTree_dhp_less_stat();
 583         void EllenBinTree_dhp_cmp_ic_stat();
 584         void EllenBinTree_dhp_cmp_ic_stat_yield();
 585         void EllenBinTree_dhp_less_pool();
 586         void EllenBinTree_dhp_less_pool_ic_stat();
 587
 588         void EllenBinTree_rcu_gpi_less();
 589         void EllenBinTree_rcu_gpi_cmp();
 590         void EllenBinTree_rcu_gpi_cmpless();
 591         void EllenBinTree_rcu_gpi_less_ic();
 592         void EllenBinTree_rcu_gpi_cmp_ic();
 593         void EllenBinTree_rcu_gpi_less_stat();
 594         void EllenBinTree_rcu_gpi_cmp_ic_stat();
 595         void EllenBinTree_rcu_gpi_cmp_ic_stat_yield();
 596         void EllenBinTree_rcu_gpi_less_pool();
 597         void EllenBinTree_rcu_gpi_less_pool_ic_stat();
 598
 599         void EllenBinTree_rcu_gpb_less();
 600         void EllenBinTree_rcu_gpb_cmp();
 601         void EllenBinTree_rcu_gpb_cmpless();
 602         void EllenBinTree_rcu_gpb_less_ic();
 603         void EllenBinTree_rcu_gpb_cmp_ic();
 604         void EllenBinTree_rcu_gpb_less_stat();
 605         void EllenBinTree_rcu_gpb_cmp_ic_stat();
 606         void EllenBinTree_rcu_gpb_cmp_ic_stat_yield();
 607         void EllenBinTree_rcu_gpb_less_pool();
 608         void EllenBinTree_rcu_gpb_less_pool_ic_stat();
 609
 610         void EllenBinTree_rcu_gpt_less();
 611         void EllenBinTree_rcu_gpt_cmp();
 612         void EllenBinTree_rcu_gpt_cmpless();
 613         void EllenBinTree_rcu_gpt_less_ic();
 614         void EllenBinTree_rcu_gpt_cmp_ic();
 615         void EllenBinTree_rcu_gpt_less_stat();
 616         void EllenBinTree_rcu_gpt_cmp_ic_stat();
 617         void EllenBinTree_rcu_gpt_cmp_ic_stat_yield();
 618         void EllenBinTree_rcu_gpt_less_pool();
 619         void EllenBinTree_rcu_gpt_less_pool_ic_stat();
 620
 621         void EllenBinTree_rcu_shb_less();
 622         void EllenBinTree_rcu_shb_cmp();
 623         void EllenBinTree_rcu_shb_cmpless();
 624         void EllenBinTree_rcu_shb_less_ic();
 625         void EllenBinTree_rcu_shb_cmp_ic();
 626         void EllenBinTree_rcu_shb_less_stat();
 627         void EllenBinTree_rcu_shb_cmp_ic_stat();
 628         void EllenBinTree_rcu_shb_cmp_ic_stat_yield();
 629         void EllenBinTree_rcu_shb_less_pool();
 630         void EllenBinTree_rcu_shb_less_pool_ic_stat();
 631
 632         void EllenBinTree_rcu_sht_less();
 633         void EllenBinTree_rcu_sht_cmp();
 634         void EllenBinTree_rcu_sht_cmpless();
 635         void EllenBinTree_rcu_sht_less_ic();
 636         void EllenBinTree_rcu_sht_cmp_ic();
 637         void EllenBinTree_rcu_sht_less_stat();
 638         void EllenBinTree_rcu_sht_cmp_ic_stat();
 639         void EllenBinTree_rcu_sht_cmp_ic_stat_yield();
 640         void EllenBinTree_rcu_sht_less_pool();
 641         void EllenBinTree_rcu_sht_less_pool_ic_stat();
 642
 643         CPPUNIT_TEST_SUITE(EllenBinTreeMapHdrTest)
 644             CPPUNIT_TEST(EllenBinTree_hp_less)
 645             CPPUNIT_TEST(EllenBinTree_hp_cmp)
 646             CPPUNIT_TEST(EllenBinTree_hp_less_stat)
 647             CPPUNIT_TEST(EllenBinTree_hp_cmpless)
 648             CPPUNIT_TEST(EllenBinTree_hp_less_ic)
 649             CPPUNIT_TEST(EllenBinTree_hp_cmp_ic)
 650             CPPUNIT_TEST(EllenBinTree_hp_cmp_ic_stat)
 651             CPPUNIT_TEST( EllenBinTree_hp_cmp_ic_stat_yield )
 652             CPPUNIT_TEST( EllenBinTree_hp_less_pool )
 653             CPPUNIT_TEST(EllenBinTree_hp_less_pool_ic_stat)
 654
 655             CPPUNIT_TEST(EllenBinTree_dhp_less)
 656             CPPUNIT_TEST(EllenBinTree_dhp_cmp)
 657             CPPUNIT_TEST(EllenBinTree_dhp_less_stat)
 658             CPPUNIT_TEST(EllenBinTree_dhp_cmpless)
 659             CPPUNIT_TEST(EllenBinTree_dhp_less_ic)
 660             CPPUNIT_TEST(EllenBinTree_dhp_cmp_ic)
 661             CPPUNIT_TEST(EllenBinTree_dhp_cmp_ic_stat)
 662             CPPUNIT_TEST( EllenBinTree_dhp_cmp_ic_stat_yield )
 663             CPPUNIT_TEST( EllenBinTree_dhp_less_pool )
 664             CPPUNIT_TEST(EllenBinTree_dhp_less_pool_ic_stat)
 665
 666             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less)
 667             CPPUNIT_TEST(EllenBinTree_rcu_gpi_cmp)
 668             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less_stat)
 669             CPPUNIT_TEST(EllenBinTree_rcu_gpi_cmpless)
 670             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less_ic)
 671             CPPUNIT_TEST(EllenBinTree_rcu_gpi_cmp_ic)
 672             CPPUNIT_TEST(EllenBinTree_rcu_gpi_cmp_ic_stat)
 673             CPPUNIT_TEST( EllenBinTree_rcu_gpi_cmp_ic_stat_yield )
 674             CPPUNIT_TEST( EllenBinTree_rcu_gpi_less_pool )
 675             CPPUNIT_TEST(EllenBinTree_rcu_gpi_less_pool_ic_stat)
 676
 677             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less)
 678             CPPUNIT_TEST(EllenBinTree_rcu_gpb_cmp)
 679             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less_stat)
 680             CPPUNIT_TEST(EllenBinTree_rcu_gpb_cmpless)
 681             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less_ic)
 682             CPPUNIT_TEST(EllenBinTree_rcu_gpb_cmp_ic)
 683             CPPUNIT_TEST(EllenBinTree_rcu_gpb_cmp_ic_stat)
 684             CPPUNIT_TEST( EllenBinTree_rcu_gpb_cmp_ic_stat_yield )
 685             CPPUNIT_TEST( EllenBinTree_rcu_gpb_less_pool )
 686             CPPUNIT_TEST(EllenBinTree_rcu_gpb_less_pool_ic_stat)
 687
 688             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less)
 689             CPPUNIT_TEST(EllenBinTree_rcu_gpt_cmp)
 690             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less_stat)
 691             CPPUNIT_TEST(EllenBinTree_rcu_gpt_cmpless)
 692             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less_ic)
 693             CPPUNIT_TEST(EllenBinTree_rcu_gpt_cmp_ic)
 694             CPPUNIT_TEST(EllenBinTree_rcu_gpt_cmp_ic_stat)
 695             CPPUNIT_TEST( EllenBinTree_rcu_gpt_cmp_ic_stat_yield )
 696             CPPUNIT_TEST( EllenBinTree_rcu_gpt_less_pool )
 697             CPPUNIT_TEST(EllenBinTree_rcu_gpt_less_pool_ic_stat)
 698
 699             CPPUNIT_TEST(EllenBinTree_rcu_shb_less)
 700             CPPUNIT_TEST(EllenBinTree_rcu_shb_cmp)
 701             CPPUNIT_TEST(EllenBinTree_rcu_shb_less_stat)
 702             CPPUNIT_TEST(EllenBinTree_rcu_shb_cmpless)
 703             CPPUNIT_TEST(EllenBinTree_rcu_shb_less_ic)
 704             CPPUNIT_TEST(EllenBinTree_rcu_shb_cmp_ic)
 705             CPPUNIT_TEST(EllenBinTree_rcu_shb_cmp_ic_stat)
 706             CPPUNIT_TEST( EllenBinTree_rcu_shb_cmp_ic_stat_yield )
 707             CPPUNIT_TEST( EllenBinTree_rcu_shb_less_pool )
 708             CPPUNIT_TEST(EllenBinTree_rcu_shb_less_pool_ic_stat)
 709
 710             CPPUNIT_TEST(EllenBinTree_rcu_sht_less)
 711             CPPUNIT_TEST(EllenBinTree_rcu_sht_cmp)
 712             CPPUNIT_TEST(EllenBinTree_rcu_sht_less_stat)
 713             CPPUNIT_TEST(EllenBinTree_rcu_sht_cmpless)
 714             CPPUNIT_TEST(EllenBinTree_rcu_sht_less_ic)
 715             CPPUNIT_TEST(EllenBinTree_rcu_sht_cmp_ic)
 716             CPPUNIT_TEST(EllenBinTree_rcu_sht_cmp_ic_stat)
 717             CPPUNIT_TEST( EllenBinTree_rcu_sht_cmp_ic_stat_yield )
 718             CPPUNIT_TEST( EllenBinTree_rcu_sht_less_pool )
 719             CPPUNIT_TEST(EllenBinTree_rcu_sht_less_pool_ic_stat)
 720
 721             CPPUNIT_TEST_SUITE_END()
 722
 723     };
 724 } // namespace tree
 725
 726 #endif // #ifndef CDSHDRTEST_ELLENBINTREE_MAP_H