tests/test-hdr/ordered_list/hdr_lazy.h

   1 //$$CDS-header$$
   2
   3 #include "cppunit/cppunit_proxy.h"
   4 #include <cds/container/details/lazy_list_base.h>
   5
   6 namespace ordlist {
   7     namespace cc = cds::container;
   8     namespace co = cds::container::opt;
   9
  10     class LazyListTestHeader: public CppUnitMini::TestCase
  11     {
  12     public:
  13         struct stat {
  14             int nEnsureExistsCall;
  15             int nEnsureNewCall;
  16
  17             stat()
  18             {
  19                 nEnsureExistsCall
  20                     = nEnsureNewCall
  21                     = 0;
  22             }
  23         };
  24
  25         struct item {
  26             int     nKey;
  27             int     nVal;
  28
  29             stat    s;
  30
  31             item(int key)
  32                 : nKey( key )
  33                 , nVal( key * 2 )
  34                 , s()
  35             {}
  36
  37             item(int key, int val)
  38                 : nKey( key )
  39                 , nVal(val)
  40                 , s()
  41             {}
  42
  43             item( item const& v )
  44                 : nKey( v.nKey )
  45                 , nVal( v.nVal )
  46                 , s()
  47             {}
  48
  49             int key() const
  50             {
  51                 return nKey;
  52             }
  53         };
  54
  55         template <typename T>
  56         struct lt
  57         {
  58             bool operator ()(const T& v1, const T& v2 ) const
  59             {
  60                 return v1.key() < v2.key();
  61             }
  62
  63             template <typename Q>
  64             bool operator ()(const T& v1, const Q& v2 ) const
  65             {
  66                 return v1.key() < v2;
  67             }
  68
  69             template <typename Q>
  70             bool operator ()(const Q& v1, const T& v2 ) const
  71             {
  72                 return v1 < v2.key();
  73             }
  74         };
  75
  76         template <typename T>
  77         struct cmp {
  78             int operator ()(const T& v1, const T& v2 ) const
  79             {
  80                 if ( v1.key() < v2.key() )
  81                     return -1;
  82                 return v1.key() > v2.key() ? 1 : 0;
  83             }
  84
  85             template <typename Q>
  86             int operator ()(const T& v1, const Q& v2 ) const
  87             {
  88                 if ( v1.key() < v2 )
  89                     return -1;
  90                 return v1.key() > v2 ? 1 : 0;
  91             }
  92
  93             template <typename Q>
  94             int operator ()(const Q& v1, const T& v2 ) const
  95             {
  96                 if ( v1 < v2.key() )
  97                     return -1;
  98                 return v1 > v2.key() ? 1 : 0;
  99             }
 100         };
 101
 102         struct insert_functor {
 103             void operator ()( item& i )
 104             {
 105                 i.nVal = i.nKey * 1033;
 106             }
 107         };
 108         struct dummy_insert_functor {
 109             void operator ()( item& i )
 110             {
 111                 // This functor should not be called
 112                 TestCase::current_test()->error( "CPPUNIT_ASSERT", "dummy_insert_functor should not be called", __FILE__, __LINE__ );
 113             }
 114         };
 115
 116         static void insert_function( item& i )
 117         {
 118             i.nVal = i.nKey * 1024;
 119         }
 120         static void dummy_insert_function( item& i )
 121         {
 122             // This function should not be called
 123             TestCase::current_test()->error( "CPPUNIT_ASSERT", "dummy_insert_function should not be called", __FILE__, __LINE__ );
 124         }
 125
 126         struct erase_functor {
 127             unsigned int nEraseCall;
 128
 129             erase_functor()
 130                 : nEraseCall(0)
 131             {}
 132
 133             void operator()( item const& /*i*/)
 134             {
 135                 ++nEraseCall;
 136             }
 137         };
 138
 139         struct check_value {
 140             unsigned int m_nMultiplier;
 141
 142             check_value( unsigned int nMultiplier )
 143                 : m_nMultiplier( nMultiplier )
 144             {}
 145
 146             check_value( const check_value& s )
 147                 : m_nMultiplier( s.m_nMultiplier )
 148             {}
 149
 150             void operator()( item& i, int )
 151             {
 152                 CPPUNIT_ASSERT_CURRENT( int(i.nKey * m_nMultiplier) == i.nVal );
 153             }
 154         };
 155
 156         struct check_exact_value {
 157             int m_nExpected;
 158
 159             check_exact_value( int nExpected )
 160                 : m_nExpected( nExpected )
 161             {}
 162
 163             check_exact_value( check_exact_value const& s)
 164                 : m_nExpected( s.m_nExpected )
 165             {}
 166
 167             void operator()( item& i, int )
 168             {
 169                 CPPUNIT_ASSERT_CURRENT( i.nVal == m_nExpected );
 170             }
 171         };
 172
 173         struct dummy_check_value {
 174             void operator()( item& i, int )
 175             {
 176                 // This functor should not be called
 177                 TestCase::current_test()->error( "CPPUNIT_ASSERT", "dummy_check_value should not be called", __FILE__, __LINE__ );
 178             }
 179         };
 180
 181         struct ensure_functor {
 182             void operator()( bool bNew, item& i, int n )
 183             {
 184                 i.nVal = i.nKey * 1024;
 185             }
 186         };
 187
 188         static void ensure_func( bool bNew, item& i, int n )
 189         {
 190             i.nVal = n * 1033;
 191         }
 192
 193         struct other_item
 194         {
 195             int nKey;
 196
 197             other_item()
 198             {}
 199
 200             other_item(int n)
 201                 : nKey(n)
 202             {}
 203         };
 204
 205         struct other_less
 206         {
 207             template <typename T1, typename T2>
 208             bool operator()( T1 const& t1, T2 const& t2 ) const
 209             {
 210                 return t1.nKey < t2.nKey;
 211             }
 212         };
 213
 214     protected:
 215         template <class OrdList>
 216         void test_with( OrdList& l )
 217         {
 218             typedef typename OrdList::value_type    value_type;
 219
 220             // The list should be empty
 221             CPPUNIT_ASSERT( l.empty() );
 222
 223             // insert test
 224             CPPUNIT_ASSERT( l.insert( 50 ) );
 225             CPPUNIT_ASSERT( l.insert( item( 25 )) );
 226             CPPUNIT_ASSERT( l.insert( item( 100 )) );
 227
 228             // insert failed - such key exists
 229             CPPUNIT_ASSERT( !l.insert( 50 ) );
 230             CPPUNIT_ASSERT( !l.insert( item( 100 )) );
 231
 232             // clear test
 233
 234             // The list should not be empty
 235             CPPUNIT_ASSERT( !l.empty() );
 236             l.clear();
 237             // and now the list is empty
 238             CPPUNIT_ASSERT( l.empty() );
 239
 240             // Test insert with functor
 241
 242             CPPUNIT_ASSERT( l.insert( 100, insert_functor() ) );
 243             // passed by ref
 244             {
 245                 insert_functor f;
 246                 CPPUNIT_ASSERT( l.insert( item(25), boost::ref(f)) );
 247                 CPPUNIT_ASSERT( !l.insert( item(100), boost::ref(f)) );
 248             }
 249             // Test insert with function
 250             CPPUNIT_ASSERT( l.insert( 50, insert_function ));
 251             CPPUNIT_ASSERT( !l.insert( 25, dummy_insert_function ));
 252             CPPUNIT_ASSERT( !l.insert( 100, dummy_insert_functor() ));
 253
 254             // The list should not be empty
 255             CPPUNIT_ASSERT( !l.empty() );
 256
 257             // Check inserted values
 258             {
 259                 int i;
 260                 i = 100;
 261
 262                 CPPUNIT_ASSERT( l.find( 100 ));
 263                 CPPUNIT_ASSERT( l.find( i, check_value(1033) ));
 264                 {
 265                     check_value f(1033);
 266                     i = 25;
 267                     CPPUNIT_ASSERT( l.find_with( 25, lt<value_type>() ));
 268                     CPPUNIT_ASSERT( l.find_with( i, lt<value_type>(), boost::ref(f) ));
 269                 }
 270                 i = 50;
 271                 CPPUNIT_ASSERT( l.find( 50 ));
 272                 CPPUNIT_ASSERT( l.find( i, check_value(1024) ));
 273
 274                 i = 10;
 275                 CPPUNIT_ASSERT( !l.find_with( 10, lt<value_type>() ));
 276                 CPPUNIT_ASSERT( !l.find_with( i, lt<value_type>(), dummy_check_value() ));
 277                 i = 75;
 278                 CPPUNIT_ASSERT( !l.find( 75 ));
 279                 CPPUNIT_ASSERT( !l.find( i, dummy_check_value() ));
 280                 i = 150;
 281                 CPPUNIT_ASSERT( !l.find( 150 ));
 282                 CPPUNIT_ASSERT( !l.find( i, dummy_check_value() ));
 283             }
 284
 285             // The list should not be empty
 286             CPPUNIT_ASSERT( !l.empty() );
 287             l.clear();
 288             // and now the list is empty
 289             CPPUNIT_ASSERT( l.empty() );
 290
 291             // Ensure test
 292             {
 293                 std::pair<bool, bool>   ensureResult;
 294                 ensure_functor f;
 295                 ensureResult = l.ensure( 100, ensure_functor() );
 296                 CPPUNIT_ASSERT( ensureResult.first );
 297                 CPPUNIT_ASSERT( ensureResult.second );
 298
 299                 ensureResult = l.ensure( 200, boost::ref(f) );
 300                 CPPUNIT_ASSERT( ensureResult.first );
 301                 CPPUNIT_ASSERT( ensureResult.second );
 302
 303                 ensureResult = l.ensure( 50, ensure_func );
 304                 CPPUNIT_ASSERT( ensureResult.first );
 305                 CPPUNIT_ASSERT( ensureResult.second );
 306
 307                 int i;
 308                 i = 100;
 309                 CPPUNIT_ASSERT( l.find( i, check_value(1024) ));
 310                 i = 50;
 311                 CPPUNIT_ASSERT( l.find( i, check_value(1033) ));
 312                 i = 200;
 313                 CPPUNIT_ASSERT( l.find( i, check_value(1024) ));
 314
 315                 // ensure existing key
 316                 ensureResult = l.ensure( 200, ensure_func );
 317                 CPPUNIT_ASSERT( ensureResult.first );
 318                 CPPUNIT_ASSERT( !ensureResult.second );
 319                 i = 200;
 320                 CPPUNIT_ASSERT( l.find( i, check_value(1033) ));
 321
 322                 ensureResult = l.ensure( 50, ensure_functor() );
 323                 CPPUNIT_ASSERT( ensureResult.first );
 324                 CPPUNIT_ASSERT( !ensureResult.second );
 325                 i = 50;
 326                 CPPUNIT_ASSERT( l.find( i, check_value(1024) ));
 327             }
 328
 329             // erase test (list: 50, 100, 200)
 330             CPPUNIT_ASSERT( !l.empty() );
 331             CPPUNIT_ASSERT( l.insert(160));
 332             CPPUNIT_ASSERT( l.insert(250));
 333             CPPUNIT_ASSERT( !l.empty() );
 334
 335             CPPUNIT_ASSERT( !l.erase( 150 ));
 336
 337             CPPUNIT_ASSERT( l.erase( 100 ));
 338             CPPUNIT_ASSERT( !l.erase( 100 ));
 339
 340             CPPUNIT_ASSERT( l.erase_with( 200, lt<value_type>() ));
 341             CPPUNIT_ASSERT( !l.erase_with( 200, lt<value_type>() ));
 342
 343             {
 344                 erase_functor ef;
 345                 CPPUNIT_ASSERT( ef.nEraseCall == 0 );
 346                 CPPUNIT_ASSERT( l.erase_with( 160, lt<value_type>(), cds::ref(ef) ));
 347                 CPPUNIT_ASSERT( ef.nEraseCall == 1 );
 348                 CPPUNIT_ASSERT( !l.erase_with( 160, lt<value_type>(), cds::ref(ef) ));
 349                 CPPUNIT_ASSERT( ef.nEraseCall == 1 );
 350
 351                 CPPUNIT_ASSERT( l.erase( 250, cds::ref(ef) ));
 352                 CPPUNIT_ASSERT( ef.nEraseCall == 2 );
 353                 CPPUNIT_ASSERT( !l.erase( 250, cds::ref(ef) ));
 354                 CPPUNIT_ASSERT( ef.nEraseCall == 2 );
 355             }
 356
 357             CPPUNIT_ASSERT( l.erase( 50 ));
 358             CPPUNIT_ASSERT( !l.erase( 50 ));
 359
 360             CPPUNIT_ASSERT( l.empty() );
 361
 362             // clear empty list
 363             l.clear();
 364             CPPUNIT_ASSERT( l.empty() );
 365
 366             {
 367                 int i;
 368                 // insert test
 369                 CPPUNIT_ASSERT( l.emplace( 501 ) );
 370                 CPPUNIT_ASSERT( l.emplace( 251, 152 ));
 371                 CPPUNIT_ASSERT( l.emplace( item( 1001 )) );
 372
 373                 // insert failed - such key exists
 374                 CPPUNIT_ASSERT( !l.emplace( 501, 2 ) );
 375                 CPPUNIT_ASSERT( !l.emplace( 251, 10) );
 376
 377                 i = 501;
 378                 CPPUNIT_ASSERT( l.find( i, check_exact_value(501*2) ));
 379                 i = 251;
 380                 CPPUNIT_ASSERT( l.find( i, check_exact_value(152) ));
 381                 i = 1001;
 382                 CPPUNIT_ASSERT( l.find( i, check_exact_value(1001*2) ));
 383
 384                 l.clear();
 385                 CPPUNIT_ASSERT( l.empty() );
 386             }
 387
 388             // Iterator test
 389             {
 390                 int nCount = 100;
 391                 for ( int i = 0; i < nCount; ++i )
 392                     CPPUNIT_ASSERT( l.insert(i) );
 393
 394                 int i = 0;
 395                 for ( typename OrdList::iterator it = l.begin(), itEnd = l.end(); it != itEnd; ++it, ++i ) {
 396                     it->nVal = i * 2;
 397                     CPPUNIT_ASSERT( it->nKey == i );
 398                 }
 399
 400                 // Check that we have visited all items
 401                 for ( int i = 0; i < nCount; ++i )
 402                     CPPUNIT_ASSERT( l.find( i, check_value(2) ));
 403
 404                 l.clear();
 405                 CPPUNIT_ASSERT( l.empty() );
 406
 407                 // Const iterator
 408                 for ( int i = 0; i < nCount; ++i )
 409                     CPPUNIT_ASSERT( l.insert(i) );
 410
 411                 i = 0;
 412                 const OrdList& rl = l;
 413                 for ( typename OrdList::const_iterator it = rl.begin(), itEnd = rl.end(); it != itEnd; ++it, ++i ) {
 414                     // it->nVal = i * 2    ;    // not!
 415                     CPPUNIT_ASSERT( it->nKey == i );
 416                 }
 417
 418                 // Check that we have visited all items
 419                 for ( int i = 0; i < nCount; ++i )
 420                     CPPUNIT_ASSERT( l.find_with( i, lt<value_type>(), check_value(2) ));
 421
 422                 l.clear();
 423                 CPPUNIT_ASSERT( l.empty() );
 424             }
 425         }
 426
 427         template <class OrdList>
 428         void test()
 429         {
 430             typedef typename OrdList::guarded_ptr guarded_ptr;
 431             typedef typename OrdList::value_type value_type;
 432
 433             OrdList l;
 434             test_with( l );
 435
 436             static int const nLimit = 20;
 437             int arr[nLimit];
 438             for ( int i = 0; i < nLimit; i++ )
 439                 arr[i] = i;
 440             std::random_shuffle( arr, arr + nLimit );
 441
 442             // extract/get
 443             for ( int i = 0; i < nLimit; ++i )
 444                 l.insert( arr[i] );
 445             {
 446                 guarded_ptr gp;
 447                 for ( int i = 0; i < nLimit; ++i ) {
 448                     int nKey = arr[i];
 449
 450                     CPPUNIT_ASSERT( l.get(gp, nKey));
 451                     CPPUNIT_ASSERT( !gp.empty());
 452                     CPPUNIT_CHECK( gp->nKey == nKey );
 453                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 454                     gp.release();
 455
 456                     CPPUNIT_ASSERT( l.extract(gp, nKey));
 457                     CPPUNIT_ASSERT( !gp.empty());
 458                     CPPUNIT_CHECK( gp->nKey == nKey );
 459                     CPPUNIT_CHECK( gp->nVal == nKey*2 );
 460                     gp.release();
 461
 462                     CPPUNIT_CHECK( !l.get(gp, nKey));
 463                     CPPUNIT_CHECK( gp.empty());
 464                     CPPUNIT_CHECK( !l.extract( gp, nKey));
 465                     CPPUNIT_CHECK( gp.empty());
 466                 }
 467                 CPPUNIT_ASSERT( l.empty());
 468                 CPPUNIT_CHECK( !l.get(gp, arr[0]));
 469                 CPPUNIT_CHECK( gp.empty());
 470                 CPPUNIT_CHECK( !l.extract( gp, arr[0]));
 471                 CPPUNIT_CHECK( gp.empty());
 472             }
 473
 474             // extract_with/get_with
 475             for ( int i = 0; i < nLimit; ++i )
 476                 l.insert( arr[i] );
 477             {
 478                 guarded_ptr gp;
 479                 for ( int i = 0; i < nLimit; ++i ) {
 480                     int nKey = arr[i];
 481                     other_item key( nKey );
 482
 483                     CPPUNIT_ASSERT( l.get_with(gp, key, other_less()));
 484                     CPPUNIT_ASSERT( !gp.empty());
 485                     CPPUNIT_CHECK( gp->nKey == nKey );
 486                     CPPUNIT_CHECK( gp->nVal == nKey * 2 );
 487                     gp.release();
 488
 489                     CPPUNIT_ASSERT( l.extract_with(gp, key, other_less()));
 490                     CPPUNIT_ASSERT( !gp.empty());
 491                     CPPUNIT_CHECK( gp->nKey == nKey );
 492                     CPPUNIT_CHECK( gp->nVal == nKey*2 );
 493                     gp.release();
 494
 495                     CPPUNIT_CHECK( !l.get_with(gp, key, other_less()));
 496                     CPPUNIT_CHECK( gp.empty());
 497                     CPPUNIT_CHECK( !l.extract_with( gp, key, other_less()));
 498                     CPPUNIT_CHECK( gp.empty());
 499                 }
 500                 CPPUNIT_ASSERT( l.empty());
 501                 CPPUNIT_CHECK( !l.get_with(gp, other_item(arr[0]), other_less()));
 502                 CPPUNIT_CHECK( gp.empty());
 503                 CPPUNIT_CHECK( !l.extract_with( gp, other_item(arr[0]), other_less()));
 504                 CPPUNIT_CHECK( gp.empty());
 505             }
 506
 507         }
 508
 509         template <class OrdList>
 510         void test_rcu()
 511         {
 512             OrdList l;
 513             test_with( l );
 514
 515             static int const nLimit = 20;
 516
 517             typedef typename OrdList::rcu_lock rcu_lock;
 518             typedef typename OrdList::value_type value_type;
 519             typedef typename OrdList::gc rcu_type;
 520
 521             {
 522                 int a[nLimit];
 523                 for (int i = 0; i < nLimit; ++i)
 524                     a[i]=i;
 525                 std::random_shuffle( a, a + nLimit );
 526
 527                 // extract/get
 528                 for ( int i = 0; i < nLimit; ++i )
 529                     CPPUNIT_ASSERT( l.insert( a[i] ) );
 530
 531                 typename OrdList::exempt_ptr ep;
 532
 533                 for ( int i = 0; i < nLimit; ++i ) {
 534                     {
 535                         rcu_lock lock;
 536                         value_type * pGet = l.get( a[i] );
 537                         CPPUNIT_ASSERT( pGet != nullptr );
 538                         CPPUNIT_CHECK( pGet->nKey == a[i] );
 539                         CPPUNIT_CHECK( pGet->nVal == a[i] * 2 );
 540
 541                         CPPUNIT_ASSERT( l.extract( ep, a[i] ));
 542                         CPPUNIT_ASSERT( !ep.empty() );
 543                         CPPUNIT_CHECK( ep->nKey == a[i] );
 544                         CPPUNIT_CHECK( (*ep).nVal == a[i] * 2 );
 545                     }
 546                     ep.release();
 547                     {
 548                         rcu_lock lock;
 549                         CPPUNIT_CHECK( l.get( a[i] ) == nullptr );
 550                         CPPUNIT_CHECK( !l.extract( ep, a[i] ));
 551                         CPPUNIT_CHECK( ep.empty() );
 552                     }
 553                 }
 554                 CPPUNIT_ASSERT( l.empty() );
 555
 556                 {
 557                     rcu_lock lock;
 558                     CPPUNIT_CHECK( l.get( a[0] ) == nullptr );
 559                     CPPUNIT_CHECK( !l.extract( ep, a[0] ) );
 560                     CPPUNIT_CHECK( ep.empty() );
 561                 }
 562
 563                 // extract_with/get_with
 564                 for ( int i = 0; i < nLimit; ++i ) {
 565                     CPPUNIT_ASSERT( l.insert( a[i] ) );
 566                 }
 567
 568                 for ( int i = 0; i < nLimit; ++i ) {
 569                     other_item itm( a[i] );
 570                     {
 571                         rcu_lock lock;
 572                         value_type * pGet = l.get_with( itm, other_less() );
 573                         CPPUNIT_ASSERT( pGet != nullptr );
 574                         CPPUNIT_CHECK( pGet->nKey == a[i] );
 575                         CPPUNIT_CHECK( pGet->nVal == a[i] * 2 );
 576
 577                         CPPUNIT_ASSERT( l.extract_with( ep, itm, other_less() ));
 578                         CPPUNIT_ASSERT( !ep.empty() );
 579                         CPPUNIT_CHECK( ep->nKey == a[i] );
 580                         CPPUNIT_CHECK( ep->nVal == a[i] * 2 );
 581                     }
 582                     ep.release();
 583                     {
 584                         rcu_lock lock;
 585                         CPPUNIT_CHECK( l.get_with( itm, other_less() ) == nullptr );
 586                         CPPUNIT_CHECK( !l.extract_with( ep, itm, other_less() ));
 587                         CPPUNIT_CHECK( ep.empty() );
 588                     }
 589                 }
 590                 CPPUNIT_ASSERT( l.empty() );
 591
 592                 {
 593                     rcu_lock lock;
 594                     CPPUNIT_CHECK( l.get_with( other_item( 0 ), other_less() ) == nullptr );
 595                     CPPUNIT_CHECK( !l.extract_with( ep, other_item(0), other_less() ));
 596                     CPPUNIT_CHECK( ep.empty() );
 597                 }
 598             }
 599         }
 600
 601         template <class OrdList>
 602         void nogc_test()
 603         {
 604             typedef OrdList list;
 605             typedef typename list::value_type    value_type;
 606             typedef std::pair<typename list::iterator, bool> ensure_result;
 607
 608             typename list::iterator it;
 609
 610             list l;
 611             CPPUNIT_ASSERT( l.empty() );
 612             CPPUNIT_ASSERT( l.insert(50) != l.end() );
 613             CPPUNIT_ASSERT( !l.empty() );
 614
 615             ensure_result eres = l.ensure( item(100, 33) );
 616             CPPUNIT_ASSERT( eres.second );
 617             CPPUNIT_ASSERT( eres.first != l.end() );
 618             CPPUNIT_ASSERT( l.insert( item(150) ) != l.end() );
 619
 620             CPPUNIT_ASSERT( l.insert(100) == l.end() );
 621             eres = l.ensure( item(50, 33) );
 622             CPPUNIT_ASSERT( !eres.second );
 623             CPPUNIT_ASSERT( eres.first->nVal == eres.first->nKey * 2 );
 624             eres.first->nVal = 63;
 625
 626             it = l.find( 33 );
 627             CPPUNIT_ASSERT( it == l.end() );
 628
 629             it = l.find( 50 );
 630             CPPUNIT_ASSERT( it != l.end() );
 631             CPPUNIT_ASSERT( it->nKey == 50 );
 632             CPPUNIT_ASSERT( it->nVal == 63 );
 633
 634             it = l.find( 100 );
 635             CPPUNIT_ASSERT( it != l.end() );
 636             CPPUNIT_ASSERT( it->nKey == 100 );
 637             CPPUNIT_ASSERT( it->nVal == 33 );
 638
 639             it = l.find_with( 150, lt<value_type>() );
 640             CPPUNIT_ASSERT( it != l.end() );
 641             CPPUNIT_ASSERT( it->nKey == 150 );
 642             CPPUNIT_ASSERT( it->nVal == it->nKey * 2 );
 643
 644             CPPUNIT_ASSERT( !l.empty() );
 645             l.clear();
 646             CPPUNIT_ASSERT( l.empty() );
 647
 648             // insert test
 649             CPPUNIT_ASSERT( l.emplace( 501 ) != l.end());
 650             CPPUNIT_ASSERT( l.emplace( 251, 152 ) != l.end());
 651             CPPUNIT_ASSERT( l.emplace( item( 1001 )) != l.end());
 652
 653             // insert failed - such key exists
 654             CPPUNIT_ASSERT( l.emplace( 501, 2 ) == l.end());
 655             CPPUNIT_ASSERT( l.emplace( 251, 10) == l.end());
 656
 657             it = l.find( 501 );
 658             CPPUNIT_ASSERT( it != l.end() );
 659             CPPUNIT_ASSERT( it->nKey == 501 );
 660             CPPUNIT_ASSERT( it->nVal == 501 * 2 );
 661
 662             it = l.find_with( 251, lt<value_type>() );
 663             CPPUNIT_ASSERT( it != l.end() );
 664             CPPUNIT_ASSERT( it->nKey == 251 );
 665             CPPUNIT_ASSERT( it->nVal == 152 );
 666
 667             it = l.find( 1001 );
 668             CPPUNIT_ASSERT( it != l.end() );
 669             CPPUNIT_ASSERT( it->nKey == 1001 );
 670             CPPUNIT_ASSERT( it->nVal == 1001 * 2 );
 671
 672             l.clear();
 673             CPPUNIT_ASSERT( l.empty() );
 674         }
 675
 676         void HP_cmp();
 677         void HP_less();
 678         void HP_cmpmix();
 679         void HP_ic();
 680
 681         void PTB_cmp();
 682         void PTB_less();
 683         void PTB_cmpmix();
 684         void PTB_ic();
 685
 686         void HRC_cmp();
 687         void HRC_less();
 688         void HRC_cmpmix();
 689         void HRC_ic();
 690
 691         void RCU_GPI_cmp();
 692         void RCU_GPI_less();
 693         void RCU_GPI_cmpmix();
 694         void RCU_GPI_ic();
 695
 696         void RCU_GPB_cmp();
 697         void RCU_GPB_less();
 698         void RCU_GPB_cmpmix();
 699         void RCU_GPB_ic();
 700
 701         void RCU_GPT_cmp();
 702         void RCU_GPT_less();
 703         void RCU_GPT_cmpmix();
 704         void RCU_GPT_ic();
 705
 706         void RCU_SHB_cmp();
 707         void RCU_SHB_less();
 708         void RCU_SHB_cmpmix();
 709         void RCU_SHB_ic();
 710
 711         void RCU_SHT_cmp();
 712         void RCU_SHT_less();
 713         void RCU_SHT_cmpmix();
 714         void RCU_SHT_ic();
 715
 716         void NOGC_cmp();
 717         void NOGC_less();
 718         void NOGC_cmpmix();
 719         void NOGC_ic();
 720
 721         CPPUNIT_TEST_SUITE(LazyListTestHeader)
 722             CPPUNIT_TEST(HP_cmp)
 723             CPPUNIT_TEST(HP_less)
 724             CPPUNIT_TEST(HP_cmpmix)
 725             CPPUNIT_TEST(HP_ic)
 726
 727             CPPUNIT_TEST(PTB_cmp)
 728             CPPUNIT_TEST(PTB_less)
 729             CPPUNIT_TEST(PTB_cmpmix)
 730             CPPUNIT_TEST(PTB_ic)
 731
 732             CPPUNIT_TEST(HRC_cmp)
 733             CPPUNIT_TEST(HRC_less)
 734             CPPUNIT_TEST(HRC_cmpmix)
 735             CPPUNIT_TEST(HRC_ic)
 736
 737             CPPUNIT_TEST(RCU_GPI_cmp)
 738             CPPUNIT_TEST(RCU_GPI_less)
 739             CPPUNIT_TEST(RCU_GPI_cmpmix)
 740             CPPUNIT_TEST(RCU_GPI_ic)
 741
 742             CPPUNIT_TEST(RCU_GPB_cmp)
 743             CPPUNIT_TEST(RCU_GPB_less)
 744             CPPUNIT_TEST(RCU_GPB_cmpmix)
 745             CPPUNIT_TEST(RCU_GPB_ic)
 746
 747             CPPUNIT_TEST(RCU_GPT_cmp)
 748             CPPUNIT_TEST(RCU_GPT_less)
 749             CPPUNIT_TEST(RCU_GPT_cmpmix)
 750             CPPUNIT_TEST(RCU_GPT_ic)
 751
 752             CPPUNIT_TEST(RCU_SHB_cmp)
 753             CPPUNIT_TEST(RCU_SHB_less)
 754             CPPUNIT_TEST(RCU_SHB_cmpmix)
 755             CPPUNIT_TEST(RCU_SHB_ic)
 756
 757             CPPUNIT_TEST(RCU_SHT_cmp)
 758             CPPUNIT_TEST(RCU_SHT_less)
 759             CPPUNIT_TEST(RCU_SHT_cmpmix)
 760             CPPUNIT_TEST(RCU_SHT_ic)
 761
 762             CPPUNIT_TEST(NOGC_cmp)
 763             CPPUNIT_TEST(NOGC_less)
 764             CPPUNIT_TEST(NOGC_cmpmix)
 765             CPPUNIT_TEST(NOGC_ic)
 766         CPPUNIT_TEST_SUITE_END()
 767     };
 768
 769 }   // namespace ordlist