test/unit/striped-set/intrusive_cuckoo_set.cpp

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
   5
   6     Source code repo: http://github.com/khizmax/libcds/
   7     Download: http://sourceforge.net/projects/libcds/files/
   8
   9     Redistribution and use in source and binary forms, with or without
  10     modification, are permitted provided that the following conditions are met:
  11
  12     * Redistributions of source code must retain the above copyright notice, this
  13       list of conditions and the following disclaimer.
  14
  15     * Redistributions in binary form must reproduce the above copyright notice,
  16       this list of conditions and the following disclaimer in the documentation
  17       and/or other materials provided with the distribution.
  18
  19     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  23     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #include "test_intrusive_set.h"
  32
  33 #include <cds/intrusive/cuckoo_set.h>
  34
  35 namespace {
  36     namespace ci = cds::intrusive;
  37
  38     class IntrusiveCuckooSet : public cds_test::intrusive_set
  39     {
  40     protected:
  41         typedef cds_test::intrusive_set base_class;
  42
  43         typedef base_class::hash_int hash1;
  44
  45
  46         template <typename Set>
  47         void test( Set& s, std::vector< typename Set::value_type >& data )
  48         {
  49             // Precondition: set is empty
  50             // Postcondition: set is empty
  51
  52             base_class::test_< Set::c_isSorted>( s, data );
  53
  54             typedef typename Set::value_type value_type;
  55             size_t const nSetSize = base_class::kSize;
  56
  57             // clear
  58             for ( auto& i : data ) {
  59                 i.clear_stat();
  60                 ASSERT_TRUE( s.insert( i ) );
  61             }
  62             ASSERT_FALSE( s.empty() );
  63             ASSERT_CONTAINER_SIZE( s, nSetSize );
  64
  65             s.clear();
  66
  67             ASSERT_TRUE( s.empty() );
  68             ASSERT_CONTAINER_SIZE( s, 0 );
  69             for ( auto& i : data ) {
  70                 EXPECT_EQ( i.nDisposeCount, 1 );
  71             }
  72
  73         }
  74
  75         //void SetUp()
  76         //{}
  77
  78         //void TearDown()
  79         //{}
  80     };
  81
  82
  83 //************************************************************
  84 // striped base hook
  85
  86     TEST_F( IntrusiveCuckooSet, striped_list_basehook_unordered )
  87     {
  88         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
  89         struct set_traits: public ci::cuckoo::traits
  90         {
  91             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
  92             typedef base_class::equal_to<item_type> equal_to;
  93             typedef mock_disposer disposer;
  94         };
  95         typedef ci::CuckooSet< item_type, set_traits > set_type;
  96
  97         std::vector< typename set_type::value_type > data;
  98         {
  99             set_type s;
 100             test( s, data );
 101         }
 102     }
 103
 104     TEST_F( IntrusiveCuckooSet, striped_vector_basehook_unordered )
 105     {
 106         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 >> item_type;
 107         struct set_traits: public ci::cuckoo::traits
 108         {
 109             typedef ci::cuckoo::base_hook< ci::cuckoo::probeset_type< item_type::probeset_type >> hook;
 110             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 111             typedef base_class::equal_to<item_type> equal_to;
 112             typedef mock_disposer disposer;
 113         };
 114         typedef ci::CuckooSet< item_type, set_traits > set_type;
 115
 116         std::vector< typename set_type::value_type > data;
 117         {
 118             set_type s( 32, 4 );
 119             test( s, data );
 120         }
 121     }
 122
 123     TEST_F( IntrusiveCuckooSet, striped_list_basehook_ordered_cmp )
 124     {
 125         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 126
 127         typedef ci::CuckooSet< item_type
 128             ,ci::cuckoo::make_traits<
 129                 ci::opt::hook< ci::cuckoo::base_hook<
 130                     ci::cuckoo::probeset_type< item_type::probeset_type >
 131                 > >
 132                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 133                 ,ci::opt::compare< cmp<item_type> >
 134                 ,ci::opt::disposer< mock_disposer >
 135             >::type
 136         > set_type;
 137
 138         std::vector< typename set_type::value_type > data;
 139         {
 140             set_type s( 32, 6, 4 );
 141             test( s, data );
 142         }
 143     }
 144
 145     TEST_F( IntrusiveCuckooSet, striped_vector_basehook_ordered_cmp )
 146     {
 147         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 >> item_type;
 148
 149         typedef ci::CuckooSet< item_type
 150             ,ci::cuckoo::make_traits<
 151                 ci::opt::hook< ci::cuckoo::base_hook<
 152                     ci::cuckoo::probeset_type< item_type::probeset_type >
 153                 > >
 154                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 155                 ,ci::opt::compare< cmp<item_type> >
 156                 , ci::opt::disposer< mock_disposer >
 157             >::type
 158         > set_type;
 159
 160         std::vector< typename set_type::value_type > data;
 161         {
 162             typename set_type::hash_tuple_type ht;
 163             set_type s( ht );
 164             test( s, data );
 165         }
 166     }
 167
 168     TEST_F( IntrusiveCuckooSet, striped_list_basehook_ordered_less )
 169     {
 170         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 171
 172         typedef ci::CuckooSet< item_type
 173             ,ci::cuckoo::make_traits<
 174                 ci::opt::hook< ci::cuckoo::base_hook<
 175                     ci::cuckoo::probeset_type< item_type::probeset_type >
 176                 > >
 177                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 178                 ,ci::opt::less< less<item_type> >
 179                 , ci::opt::disposer< mock_disposer >
 180             >::type
 181         > set_type;
 182
 183         std::vector< typename set_type::value_type > data;
 184         {
 185             typename set_type::hash_tuple_type ht;
 186             set_type s( 32, 6, 4, ht );
 187             test( s, data );
 188         }
 189     }
 190
 191     TEST_F( IntrusiveCuckooSet, striped_vector_basehook_ordered_less )
 192     {
 193         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 194
 195         typedef ci::CuckooSet< item_type
 196             ,ci::cuckoo::make_traits<
 197                 ci::opt::hook< ci::cuckoo::base_hook<
 198                     ci::cuckoo::probeset_type< item_type::probeset_type >
 199                 > >
 200                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 201                 ,ci::opt::less< less<item_type> >
 202                 ,ci::opt::disposer< mock_disposer >
 203             >::type
 204         > set_type;
 205
 206         std::vector< typename set_type::value_type > data;
 207         {
 208             typename set_type::hash_tuple_type ht;
 209             set_type s( std::move( ht ));
 210             test( s, data );
 211         }
 212     }
 213
 214     TEST_F( IntrusiveCuckooSet, striped_list_basehook_ordered_cmpmix )
 215     {
 216         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 217
 218         typedef ci::CuckooSet< item_type
 219             ,ci::cuckoo::make_traits<
 220                 ci::opt::hook< ci::cuckoo::base_hook<
 221                     ci::cuckoo::probeset_type< item_type::probeset_type >
 222                 > >
 223                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 224                 ,ci::opt::less< less<item_type> >
 225                 ,ci::opt::compare< cmp<item_type> >
 226                 ,ci::opt::disposer< mock_disposer >
 227             >::type
 228         > set_type;
 229
 230         std::vector< typename set_type::value_type > data;
 231         {
 232             typename set_type::hash_tuple_type ht;
 233             set_type s( 32, 6, 0, std::move( ht ));
 234             test( s, data );
 235         }
 236     }
 237
 238     TEST_F( IntrusiveCuckooSet, striped_vector_basehook_ordered_cmpmix )
 239     {
 240         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 241
 242         typedef ci::CuckooSet< item_type
 243             ,ci::cuckoo::make_traits<
 244                 ci::opt::hook< ci::cuckoo::base_hook<
 245                     ci::cuckoo::probeset_type< item_type::probeset_type >
 246                 > >
 247                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 248                 ,ci::opt::less< less<item_type> >
 249                 ,ci::opt::compare< cmp<item_type> >
 250                 ,ci::opt::disposer< mock_disposer >
 251             >::type
 252         > set_type;
 253
 254         std::vector< typename set_type::value_type > data;
 255         {
 256             typename set_type::hash_tuple_type ht;
 257             set_type s( std::move( ht ));
 258             test( s, data );
 259         }
 260     }
 261
 262     TEST_F( IntrusiveCuckooSet, striped_list_basehook_ordered_stat )
 263     {
 264         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 265
 266         typedef ci::CuckooSet< item_type
 267             ,ci::cuckoo::make_traits<
 268                 ci::opt::hook< ci::cuckoo::base_hook<
 269                     ci::cuckoo::probeset_type< item_type::probeset_type >
 270                 > >
 271                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 272                 ,ci::opt::less< less<item_type> >
 273                 ,ci::opt::compare< cmp<item_type> >
 274                 ,ci::opt::stat< ci::cuckoo::stat >
 275                 ,ci::opt::disposer< mock_disposer >
 276             >::type
 277         > set_type;
 278
 279         std::vector< typename set_type::value_type > data;
 280         {
 281             set_type s;
 282             test( s, data );
 283         }
 284     }
 285
 286     TEST_F( IntrusiveCuckooSet, striped_vector_basehook_ordered_stat )
 287     {
 288         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 289
 290         typedef ci::CuckooSet< item_type
 291             ,ci::cuckoo::make_traits<
 292                 ci::opt::hook< ci::cuckoo::base_hook<
 293                     ci::cuckoo::probeset_type< item_type::probeset_type >
 294                 > >
 295                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 296                 ,ci::opt::less< less<item_type> >
 297                 ,ci::opt::compare< cmp<item_type> >
 298                 ,ci::opt::stat< ci::cuckoo::stat >
 299                 ,ci::opt::disposer< mock_disposer >
 300             >::type
 301         > set_type;
 302
 303         std::vector< typename set_type::value_type > data;
 304         {
 305             set_type s;
 306             test( s, data );
 307         }
 308     }
 309
 310     TEST_F( IntrusiveCuckooSet, striped_list_basehook_unordered_storehash )
 311     {
 312         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 2 >> item_type;
 313         struct set_traits: public ci::cuckoo::traits
 314         {
 315             typedef ci::cuckoo::base_hook<
 316                 ci::cuckoo::probeset_type< item_type::probeset_type >
 317                 ,ci::cuckoo::store_hash< item_type::hash_array_size >
 318             > hook;
 319             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 320             typedef base_class::equal_to<item_type> equal_to;
 321             typedef mock_disposer disposer;
 322             typedef ci::cuckoo::stat stat;
 323         };
 324         typedef ci::CuckooSet< item_type, set_traits > set_type;
 325
 326         std::vector< typename set_type::value_type > data;
 327         {
 328             set_type s;
 329             test( s, data );
 330         }
 331     }
 332
 333     TEST_F( IntrusiveCuckooSet, striped_vector_basehook_unordered_storehash )
 334     {
 335         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 >> item_type;
 336         struct set_traits: public ci::cuckoo::traits
 337         {
 338             typedef ci::cuckoo::base_hook<
 339                 ci::cuckoo::probeset_type< item_type::probeset_type >
 340                 ,ci::cuckoo::store_hash< item_type::hash_array_size >
 341             > hook;
 342             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 343             typedef base_class::equal_to<item_type> equal_to;
 344             typedef mock_disposer disposer;
 345             typedef ci::cuckoo::stat stat;
 346         };
 347         typedef ci::CuckooSet< item_type, set_traits > set_type;
 348
 349         std::vector< typename set_type::value_type > data;
 350         {
 351             set_type s( 32, 4 );
 352             test( s, data );
 353         }
 354     }
 355
 356     TEST_F( IntrusiveCuckooSet, striped_list_basehook_ordered_storehash )
 357     {
 358         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 2 >> item_type;
 359
 360         typedef ci::CuckooSet< item_type
 361             ,ci::cuckoo::make_traits<
 362                 ci::opt::hook< ci::cuckoo::base_hook<
 363                     ci::cuckoo::probeset_type< item_type::probeset_type >
 364                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 365                 > >
 366                 ,cds::opt::hash< std::tuple< hash1, hash2 > >
 367                 ,cds::opt::less< less<item_type> >
 368                 ,cds::opt::compare< cmp<item_type> >
 369                 ,ci::opt::disposer< mock_disposer >
 370             >::type
 371         > set_type;
 372
 373         std::vector< typename set_type::value_type > data;
 374         {
 375             typename set_type::hash_tuple_type ht;
 376             set_type s( 32, 6, 0, std::move( ht ));
 377             test( s, data );
 378         }
 379     }
 380
 381     TEST_F( IntrusiveCuckooSet, striped_vector_basehook_ordered_storehash )
 382     {
 383         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 2 >> item_type;
 384
 385         typedef ci::CuckooSet< item_type
 386             ,ci::cuckoo::make_traits<
 387                 ci::opt::hook< ci::cuckoo::base_hook<
 388                     ci::cuckoo::probeset_type< item_type::probeset_type >
 389                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 390                 > >
 391                 ,cds::opt::hash< std::tuple< hash1, hash2 > >
 392                 ,cds::opt::less< less<item_type> >
 393                 ,cds::opt::compare< cmp<item_type> >
 394                 ,ci::opt::disposer< mock_disposer >
 395             >::type
 396         > set_type;
 397
 398         std::vector< typename set_type::value_type > data;
 399         {
 400             typename set_type::hash_tuple_type ht;
 401             set_type s( std::move( ht ));
 402             test( s, data );
 403         }
 404     }
 405
 406 //************************************************************
 407 // striped member hook
 408
 409     TEST_F( IntrusiveCuckooSet, striped_list_memberhook_unordered )
 410     {
 411         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
 412         struct set_traits: public ci::cuckoo::traits
 413         {
 414             typedef ci::cuckoo::member_hook< offsetof( item_type, hMember )> hook;
 415             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 416             typedef base_class::equal_to<item_type> equal_to;
 417             typedef mock_disposer disposer;
 418         };
 419         typedef ci::CuckooSet< item_type, set_traits > set_type;
 420
 421         std::vector< typename set_type::value_type > data;
 422         {
 423             set_type s;
 424             test( s, data );
 425         }
 426     }
 427
 428     TEST_F( IntrusiveCuckooSet, striped_vector_memberhook_unordered )
 429     {
 430         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 >> item_type;
 431         struct set_traits: public ci::cuckoo::traits
 432         {
 433
 434             typedef ci::cuckoo::member_hook< offsetof( item_type, hMember ), ci::cuckoo::probeset_type< item_type::member_type::probeset_type >> hook;
 435             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 436             typedef base_class::equal_to<item_type> equal_to;
 437             typedef mock_disposer disposer;
 438         };
 439         typedef ci::CuckooSet< item_type, set_traits > set_type;
 440
 441         std::vector< typename set_type::value_type > data;
 442         {
 443             set_type s( 32, 4 );
 444             test( s, data );
 445         }
 446     }
 447
 448     TEST_F( IntrusiveCuckooSet, striped_list_memberhook_ordered_cmp )
 449     {
 450         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 451
 452         typedef ci::CuckooSet< item_type
 453             ,ci::cuckoo::make_traits<
 454                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 455                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 456                 > >
 457                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 458                 ,ci::opt::compare< cmp<item_type> >
 459                 ,ci::opt::disposer< mock_disposer >
 460             >::type
 461         > set_type;
 462
 463         std::vector< typename set_type::value_type > data;
 464         {
 465             set_type s( 32, 6, 4 );
 466             test( s, data );
 467         }
 468     }
 469
 470     TEST_F( IntrusiveCuckooSet, striped_vector_memberhook_ordered_cmp )
 471     {
 472         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 >> item_type;
 473
 474         typedef ci::CuckooSet< item_type
 475             ,ci::cuckoo::make_traits<
 476                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 477                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 478                 > >
 479                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 480                 ,ci::opt::compare< cmp<item_type> >
 481                 , ci::opt::disposer< mock_disposer >
 482             >::type
 483         > set_type;
 484
 485         std::vector< typename set_type::value_type > data;
 486         {
 487             typename set_type::hash_tuple_type ht;
 488             set_type s( ht );
 489             test( s, data );
 490         }
 491     }
 492
 493     TEST_F( IntrusiveCuckooSet, striped_list_memberhook_ordered_less )
 494     {
 495         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 496
 497         typedef ci::CuckooSet< item_type
 498             ,ci::cuckoo::make_traits<
 499                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 500                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 501                 > >
 502                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 503                 ,ci::opt::less< less<item_type> >
 504                 , ci::opt::disposer< mock_disposer >
 505             >::type
 506         > set_type;
 507
 508         std::vector< typename set_type::value_type > data;
 509         {
 510             typename set_type::hash_tuple_type ht;
 511             set_type s( 32, 6, 4, ht );
 512             test( s, data );
 513         }
 514     }
 515
 516     TEST_F( IntrusiveCuckooSet, striped_vector_memberhook_ordered_less )
 517     {
 518         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 519
 520         typedef ci::CuckooSet< item_type
 521             ,ci::cuckoo::make_traits<
 522                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 523                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 524                 > >
 525                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 526                 ,ci::opt::less< less<item_type> >
 527                 ,ci::opt::disposer< mock_disposer >
 528             >::type
 529         > set_type;
 530
 531         std::vector< typename set_type::value_type > data;
 532         {
 533             typename set_type::hash_tuple_type ht;
 534             set_type s( std::move( ht ));
 535             test( s, data );
 536         }
 537     }
 538
 539     TEST_F( IntrusiveCuckooSet, striped_list_memberhook_ordered_cmpmix )
 540     {
 541         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 542
 543         typedef ci::CuckooSet< item_type
 544             ,ci::cuckoo::make_traits<
 545                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 546                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 547                 > >
 548                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 549                 ,ci::opt::less< less<item_type> >
 550                 ,ci::opt::compare< cmp<item_type> >
 551                 ,ci::opt::disposer< mock_disposer >
 552             >::type
 553         > set_type;
 554
 555         std::vector< typename set_type::value_type > data;
 556         {
 557             typename set_type::hash_tuple_type ht;
 558             set_type s( 32, 6, 0, std::move( ht ));
 559             test( s, data );
 560         }
 561     }
 562
 563     TEST_F( IntrusiveCuckooSet, striped_vector_memberhook_ordered_cmpmix )
 564     {
 565         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 566
 567         typedef ci::CuckooSet< item_type
 568             ,ci::cuckoo::make_traits<
 569                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 570                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 571                 > >
 572                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 573                 ,ci::opt::less< less<item_type> >
 574                 ,ci::opt::compare< cmp<item_type> >
 575                 ,ci::opt::disposer< mock_disposer >
 576             >::type
 577         > set_type;
 578
 579         std::vector< typename set_type::value_type > data;
 580         {
 581             typename set_type::hash_tuple_type ht;
 582             set_type s( std::move( ht ));
 583             test( s, data );
 584         }
 585     }
 586
 587     TEST_F( IntrusiveCuckooSet, striped_list_memberhook_ordered_stat )
 588     {
 589         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 590
 591         typedef ci::CuckooSet< item_type
 592             ,ci::cuckoo::make_traits<
 593                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 594                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 595                 > >
 596                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 597                 ,ci::opt::less< less<item_type> >
 598                 ,ci::opt::compare< cmp<item_type> >
 599                 ,ci::opt::stat< ci::cuckoo::stat >
 600                 ,ci::opt::disposer< mock_disposer >
 601             >::type
 602         > set_type;
 603
 604         std::vector< typename set_type::value_type > data;
 605         {
 606             set_type s;
 607             test( s, data );
 608         }
 609     }
 610
 611     TEST_F( IntrusiveCuckooSet, striped_vector_memberhook_ordered_stat )
 612     {
 613         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 614
 615         typedef ci::CuckooSet< item_type
 616             ,ci::cuckoo::make_traits<
 617                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 618                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 619                 > >
 620                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 621                 ,ci::opt::less< less<item_type> >
 622                 ,ci::opt::compare< cmp<item_type> >
 623                 ,ci::opt::stat< ci::cuckoo::stat >
 624                 ,ci::opt::disposer< mock_disposer >
 625             >::type
 626         > set_type;
 627
 628         std::vector< typename set_type::value_type > data;
 629         {
 630             set_type s;
 631             test( s, data );
 632         }
 633     }
 634
 635     TEST_F( IntrusiveCuckooSet, striped_list_memberhook_unordered_storehash )
 636     {
 637         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 2 >> item_type;
 638         struct set_traits: public ci::cuckoo::traits
 639         {
 640             typedef ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 641                 ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 642                 ,ci::cuckoo::store_hash< item_type::member_type::hash_array_size >
 643             > hook;
 644             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 645             typedef base_class::equal_to<item_type> equal_to;
 646             typedef mock_disposer disposer;
 647             typedef ci::cuckoo::stat stat;
 648         };
 649         typedef ci::CuckooSet< item_type, set_traits > set_type;
 650
 651         std::vector< typename set_type::value_type > data;
 652         {
 653             set_type s;
 654             test( s, data );
 655         }
 656     }
 657
 658     TEST_F( IntrusiveCuckooSet, striped_vector_memberhook_unordered_storehash )
 659     {
 660         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 >> item_type;
 661         struct set_traits: public ci::cuckoo::traits
 662         {
 663             typedef ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 664                 ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 665                 ,ci::cuckoo::store_hash< item_type::member_type::hash_array_size >
 666             > hook;
 667             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 668             typedef base_class::equal_to<item_type> equal_to;
 669             typedef mock_disposer disposer;
 670             typedef ci::cuckoo::stat stat;
 671         };
 672         typedef ci::CuckooSet< item_type, set_traits > set_type;
 673
 674         std::vector< typename set_type::value_type > data;
 675         {
 676             set_type s( 32, 4 );
 677             test( s, data );
 678         }
 679     }
 680
 681     TEST_F( IntrusiveCuckooSet, striped_list_memberhook_ordered_storehash )
 682     {
 683         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 2 >> item_type;
 684
 685         typedef ci::CuckooSet< item_type
 686             ,ci::cuckoo::make_traits<
 687                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 688                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 689                     ,ci::cuckoo::store_hash< item_type::member_type::hash_array_size >
 690                 > >
 691                 ,cds::opt::hash< std::tuple< hash1, hash2 > >
 692                 ,cds::opt::less< less<item_type> >
 693                 ,cds::opt::compare< cmp<item_type> >
 694                 ,ci::opt::disposer< mock_disposer >
 695             >::type
 696         > set_type;
 697
 698         std::vector< typename set_type::value_type > data;
 699         {
 700             typename set_type::hash_tuple_type ht;
 701             set_type s( 32, 6, 0, std::move( ht ));
 702             test( s, data );
 703         }
 704     }
 705
 706     TEST_F( IntrusiveCuckooSet, striped_vector_memberhook_ordered_storehash )
 707     {
 708         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 2 >> item_type;
 709
 710         typedef ci::CuckooSet< item_type
 711             ,ci::cuckoo::make_traits<
 712                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
 713                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
 714                     ,ci::cuckoo::store_hash< item_type::member_type::hash_array_size >
 715                 > >
 716                 ,cds::opt::hash< std::tuple< hash1, hash2 > >
 717                 ,cds::opt::less< less<item_type> >
 718                 ,cds::opt::compare< cmp<item_type> >
 719                 ,ci::opt::disposer< mock_disposer >
 720             >::type
 721         > set_type;
 722
 723         std::vector< typename set_type::value_type > data;
 724         {
 725             typename set_type::hash_tuple_type ht;
 726             set_type s( std::move( ht ));
 727             test( s, data );
 728         }
 729     }
 730
 731 //************************************************************
 732 // refinable base hook
 733
 734     TEST_F( IntrusiveCuckooSet, refinable_list_basehook_unordered )
 735     {
 736         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
 737         struct set_traits: public ci::cuckoo::traits
 738         {
 739             typedef ci::cuckoo::refinable<> mutex_policy;
 740             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 741             typedef base_class::equal_to<item_type> equal_to;
 742             typedef mock_disposer disposer;
 743         };
 744         typedef ci::CuckooSet< item_type, set_traits > set_type;
 745
 746         std::vector< typename set_type::value_type > data;
 747         {
 748             set_type s;
 749             test( s, data );
 750         }
 751     }
 752
 753     TEST_F( IntrusiveCuckooSet, refinable_vector_basehook_unordered )
 754     {
 755         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 >> item_type;
 756         struct set_traits: public ci::cuckoo::traits
 757         {
 758             typedef ci::cuckoo::refinable<> mutex_policy;
 759             typedef ci::cuckoo::base_hook< ci::cuckoo::probeset_type< item_type::probeset_type >> hook;
 760             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 761             typedef base_class::equal_to<item_type> equal_to;
 762             typedef mock_disposer disposer;
 763         };
 764         typedef ci::CuckooSet< item_type, set_traits > set_type;
 765
 766         std::vector< typename set_type::value_type > data;
 767         {
 768             set_type s( 32, 4 );
 769             test( s, data );
 770         }
 771     }
 772
 773     TEST_F( IntrusiveCuckooSet, refinable_list_basehook_ordered_cmp )
 774     {
 775         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 776
 777         typedef ci::CuckooSet< item_type
 778             ,ci::cuckoo::make_traits<
 779                 ci::opt::hook< ci::cuckoo::base_hook<
 780                     ci::cuckoo::probeset_type< item_type::probeset_type >
 781                 > >
 782                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
 783                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 784                 ,ci::opt::compare< cmp<item_type> >
 785                 ,ci::opt::disposer< mock_disposer >
 786             >::type
 787         > set_type;
 788
 789         std::vector< typename set_type::value_type > data;
 790         {
 791             set_type s( 32, 6, 4 );
 792             test( s, data );
 793         }
 794     }
 795
 796     TEST_F( IntrusiveCuckooSet, refinable_vector_basehook_ordered_cmp )
 797     {
 798         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 >> item_type;
 799
 800         typedef ci::CuckooSet< item_type
 801             ,ci::cuckoo::make_traits<
 802                 ci::opt::hook< ci::cuckoo::base_hook<
 803                     ci::cuckoo::probeset_type< item_type::probeset_type >
 804                 > >
 805                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
 806                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 807                 ,ci::opt::compare< cmp<item_type> >
 808                 , ci::opt::disposer< mock_disposer >
 809             >::type
 810         > set_type;
 811
 812         std::vector< typename set_type::value_type > data;
 813         {
 814             typename set_type::hash_tuple_type ht;
 815             set_type s( ht );
 816             test( s, data );
 817         }
 818     }
 819
 820     TEST_F( IntrusiveCuckooSet, refinable_list_basehook_ordered_less )
 821     {
 822         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 823
 824         typedef ci::CuckooSet< item_type
 825             ,ci::cuckoo::make_traits<
 826                 ci::opt::hook< ci::cuckoo::base_hook<
 827                     ci::cuckoo::probeset_type< item_type::probeset_type >
 828                 > >
 829                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
 830                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 831                 ,ci::opt::less< less<item_type> >
 832                 ,ci::opt::disposer< mock_disposer >
 833             >::type
 834         > set_type;
 835
 836         std::vector< typename set_type::value_type > data;
 837         {
 838             typename set_type::hash_tuple_type ht;
 839             set_type s( 32, 6, 4, ht );
 840             test( s, data );
 841         }
 842     }
 843
 844     TEST_F( IntrusiveCuckooSet, refinable_vector_basehook_ordered_less )
 845     {
 846         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 847
 848         typedef ci::CuckooSet< item_type
 849             ,ci::cuckoo::make_traits<
 850                 ci::opt::hook< ci::cuckoo::base_hook<
 851                     ci::cuckoo::probeset_type< item_type::probeset_type >
 852                 > >
 853                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
 854                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 855                 ,ci::opt::less< less<item_type> >
 856                 ,ci::opt::disposer< mock_disposer >
 857             >::type
 858         > set_type;
 859
 860         std::vector< typename set_type::value_type > data;
 861         {
 862             typename set_type::hash_tuple_type ht;
 863             set_type s( std::move( ht ));
 864             test( s, data );
 865         }
 866     }
 867
 868     TEST_F( IntrusiveCuckooSet, refinable_list_basehook_ordered_cmpmix )
 869     {
 870         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 871
 872         typedef ci::CuckooSet< item_type
 873             ,ci::cuckoo::make_traits<
 874                 ci::opt::hook< ci::cuckoo::base_hook<
 875                     ci::cuckoo::probeset_type< item_type::probeset_type >
 876                 > >
 877                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
 878                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 879                 ,ci::opt::less< less<item_type> >
 880                 ,ci::opt::compare< cmp<item_type> >
 881                 ,ci::opt::disposer< mock_disposer >
 882             >::type
 883         > set_type;
 884
 885         std::vector< typename set_type::value_type > data;
 886         {
 887             typename set_type::hash_tuple_type ht;
 888             set_type s( 32, 6, 0, std::move( ht ));
 889             test( s, data );
 890         }
 891     }
 892
 893     TEST_F( IntrusiveCuckooSet, refinable_vector_basehook_ordered_cmpmix )
 894     {
 895         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 896
 897         typedef ci::CuckooSet< item_type
 898             ,ci::cuckoo::make_traits<
 899                 ci::opt::hook< ci::cuckoo::base_hook<
 900                     ci::cuckoo::probeset_type< item_type::probeset_type >
 901                 > >
 902                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
 903                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 904                 ,ci::opt::less< less<item_type> >
 905                 ,ci::opt::compare< cmp<item_type> >
 906                 ,ci::opt::disposer< mock_disposer >
 907             >::type
 908         > set_type;
 909
 910         std::vector< typename set_type::value_type > data;
 911         {
 912             typename set_type::hash_tuple_type ht;
 913             set_type s( std::move( ht ));
 914             test( s, data );
 915         }
 916     }
 917
 918     TEST_F( IntrusiveCuckooSet, refinable_list_basehook_ordered_stat )
 919     {
 920         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
 921
 922         typedef ci::CuckooSet< item_type
 923             ,ci::cuckoo::make_traits<
 924                 ci::opt::hook< ci::cuckoo::base_hook<
 925                     ci::cuckoo::probeset_type< item_type::probeset_type >
 926                 > >
 927                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
 928                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 929                 ,ci::opt::less< less<item_type> >
 930                 ,ci::opt::compare< cmp<item_type> >
 931                 ,ci::opt::stat< ci::cuckoo::stat >
 932                 ,ci::opt::disposer< mock_disposer >
 933             >::type
 934         > set_type;
 935
 936         std::vector< typename set_type::value_type > data;
 937         {
 938             set_type s;
 939             test( s, data );
 940         }
 941     }
 942
 943     TEST_F( IntrusiveCuckooSet, refinable_vector_basehook_ordered_stat )
 944     {
 945         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
 946
 947         typedef ci::CuckooSet< item_type
 948             ,ci::cuckoo::make_traits<
 949                 ci::opt::hook< ci::cuckoo::base_hook<
 950                     ci::cuckoo::probeset_type< item_type::probeset_type >
 951                 > >
 952                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
 953                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
 954                 ,ci::opt::less< less<item_type> >
 955                 ,ci::opt::compare< cmp<item_type> >
 956                 ,ci::opt::stat< ci::cuckoo::stat >
 957                 ,ci::opt::disposer< mock_disposer >
 958             >::type
 959         > set_type;
 960
 961         std::vector< typename set_type::value_type > data;
 962         {
 963             set_type s;
 964             test( s, data );
 965         }
 966     }
 967
 968     TEST_F( IntrusiveCuckooSet, refinable_list_basehook_unordered_storehash )
 969     {
 970         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 2 >> item_type;
 971         struct set_traits: public ci::cuckoo::traits
 972         {
 973             typedef ci::cuckoo::base_hook<
 974                 ci::cuckoo::probeset_type< item_type::probeset_type >
 975                 ,ci::cuckoo::store_hash< item_type::hash_array_size >
 976             > hook;
 977             typedef ci::cuckoo::refinable<> mutex_policy;
 978             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
 979             typedef base_class::equal_to<item_type> equal_to;
 980             typedef mock_disposer disposer;
 981             typedef ci::cuckoo::stat stat;
 982         };
 983         typedef ci::CuckooSet< item_type, set_traits > set_type;
 984
 985         std::vector< typename set_type::value_type > data;
 986         {
 987             set_type s;
 988             test( s, data );
 989         }
 990     }
 991
 992     TEST_F( IntrusiveCuckooSet, refinable_vector_basehook_unordered_storehash )
 993     {
 994         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 >> item_type;
 995         struct set_traits: public ci::cuckoo::traits
 996         {
 997             typedef ci::cuckoo::base_hook<
 998                 ci::cuckoo::probeset_type< item_type::probeset_type >
 999                 ,ci::cuckoo::store_hash< item_type::hash_array_size >
1000             > hook;
1001             typedef ci::cuckoo::refinable<> mutex_policy;
1002             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
1003             typedef base_class::equal_to<item_type> equal_to;
1004             typedef mock_disposer disposer;
1005             typedef ci::cuckoo::stat stat;
1006         };
1007         typedef ci::CuckooSet< item_type, set_traits > set_type;
1008
1009         std::vector< typename set_type::value_type > data;
1010         {
1011             set_type s( 32, 4 );
1012             test( s, data );
1013         }
1014     }
1015
1016     TEST_F( IntrusiveCuckooSet, refinable_list_basehook_ordered_storehash )
1017     {
1018         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::list, 2 >> item_type;
1019
1020         typedef ci::CuckooSet< item_type
1021             ,ci::cuckoo::make_traits<
1022                 ci::opt::hook< ci::cuckoo::base_hook<
1023                     ci::cuckoo::probeset_type< item_type::probeset_type >
1024                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
1025                 > >
1026                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1027                 ,cds::opt::hash< std::tuple< hash1, hash2 > >
1028                 ,cds::opt::less< less<item_type> >
1029                 ,cds::opt::compare< cmp<item_type> >
1030                 ,ci::opt::disposer< mock_disposer >
1031             >::type
1032         > set_type;
1033
1034         std::vector< typename set_type::value_type > data;
1035         {
1036             typename set_type::hash_tuple_type ht;
1037             set_type s( 32, 6, 0, std::move( ht ));
1038             test( s, data );
1039         }
1040     }
1041
1042     TEST_F( IntrusiveCuckooSet, refinable_vector_basehook_ordered_storehash )
1043     {
1044         typedef base_class::base_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 2 >> item_type;
1045
1046         typedef ci::CuckooSet< item_type
1047             ,ci::cuckoo::make_traits<
1048                 ci::opt::hook< ci::cuckoo::base_hook<
1049                     ci::cuckoo::probeset_type< item_type::probeset_type >
1050                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
1051                 > >
1052                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1053                 ,cds::opt::hash< std::tuple< hash1, hash2 > >
1054                 ,cds::opt::less< less<item_type> >
1055                 ,cds::opt::compare< cmp<item_type> >
1056                 ,ci::opt::disposer< mock_disposer >
1057             >::type
1058         > set_type;
1059
1060         std::vector< typename set_type::value_type > data;
1061         {
1062             typename set_type::hash_tuple_type ht;
1063             set_type s( std::move( ht ));
1064             test( s, data );
1065         }
1066     }
1067
1068 //************************************************************
1069 // refinable member hook
1070
1071     TEST_F( IntrusiveCuckooSet, refinable_list_memberhook_unordered )
1072     {
1073         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
1074         struct set_traits: public ci::cuckoo::traits
1075         {
1076             typedef ci::cuckoo::member_hook< offsetof( item_type, hMember )> hook;
1077             typedef ci::cuckoo::refinable<> mutex_policy;
1078             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
1079             typedef base_class::equal_to<item_type> equal_to;
1080             typedef mock_disposer disposer;
1081         };
1082         typedef ci::CuckooSet< item_type, set_traits > set_type;
1083
1084         std::vector< typename set_type::value_type > data;
1085         {
1086             set_type s;
1087             test( s, data );
1088         }
1089     }
1090
1091     TEST_F( IntrusiveCuckooSet, refinable_vector_memberhook_unordered )
1092     {
1093         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 >> item_type;
1094         struct set_traits: public ci::cuckoo::traits
1095         {
1096
1097             typedef ci::cuckoo::member_hook< offsetof( item_type, hMember ), ci::cuckoo::probeset_type< item_type::member_type::probeset_type >> hook;
1098             typedef ci::cuckoo::refinable<> mutex_policy;
1099             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
1100             typedef base_class::equal_to<item_type> equal_to;
1101             typedef mock_disposer disposer;
1102         };
1103         typedef ci::CuckooSet< item_type, set_traits > set_type;
1104
1105         std::vector< typename set_type::value_type > data;
1106         {
1107             set_type s( 32, 4 );
1108             test( s, data );
1109         }
1110     }
1111
1112     TEST_F( IntrusiveCuckooSet, refinable_list_memberhook_ordered_cmp )
1113     {
1114         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
1115
1116         typedef ci::CuckooSet< item_type
1117             ,ci::cuckoo::make_traits<
1118                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1119                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1120                 > >
1121                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1122                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
1123                 ,ci::opt::compare< cmp<item_type> >
1124                 ,ci::opt::disposer< mock_disposer >
1125             >::type
1126         > set_type;
1127
1128         std::vector< typename set_type::value_type > data;
1129         {
1130             set_type s( 32, 6, 4 );
1131             test( s, data );
1132         }
1133     }
1134
1135     TEST_F( IntrusiveCuckooSet, refinable_vector_memberhook_ordered_cmp )
1136     {
1137         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 >> item_type;
1138
1139         typedef ci::CuckooSet< item_type
1140             ,ci::cuckoo::make_traits<
1141                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1142                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1143                 > >
1144                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1145                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
1146                 ,ci::opt::compare< cmp<item_type> >
1147                 ,ci::opt::disposer< mock_disposer >
1148             >::type
1149         > set_type;
1150
1151         std::vector< typename set_type::value_type > data;
1152         {
1153             typename set_type::hash_tuple_type ht;
1154             set_type s( ht );
1155             test( s, data );
1156         }
1157     }
1158
1159     TEST_F( IntrusiveCuckooSet, refinable_list_memberhook_ordered_less )
1160     {
1161         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
1162
1163         typedef ci::CuckooSet< item_type
1164             ,ci::cuckoo::make_traits<
1165                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1166                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1167                 > >
1168                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1169                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
1170                 ,ci::opt::less< less<item_type> >
1171                 ,ci::opt::disposer< mock_disposer >
1172             >::type
1173         > set_type;
1174
1175         std::vector< typename set_type::value_type > data;
1176         {
1177             typename set_type::hash_tuple_type ht;
1178             set_type s( 32, 6, 4, ht );
1179             test( s, data );
1180         }
1181     }
1182
1183     TEST_F( IntrusiveCuckooSet, refinable_vector_memberhook_ordered_less )
1184     {
1185         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
1186
1187         typedef ci::CuckooSet< item_type
1188             ,ci::cuckoo::make_traits<
1189                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1190                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1191                 > >
1192                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1193                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
1194                 ,ci::opt::less< less<item_type> >
1195                 ,ci::opt::disposer< mock_disposer >
1196             >::type
1197         > set_type;
1198
1199         std::vector< typename set_type::value_type > data;
1200         {
1201             typename set_type::hash_tuple_type ht;
1202             set_type s( std::move( ht ));
1203             test( s, data );
1204         }
1205     }
1206
1207     TEST_F( IntrusiveCuckooSet, refinable_list_memberhook_ordered_cmpmix )
1208     {
1209         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
1210
1211         typedef ci::CuckooSet< item_type
1212             ,ci::cuckoo::make_traits<
1213                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1214                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1215                 > >
1216                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1217                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
1218                 ,ci::opt::less< less<item_type> >
1219                 ,ci::opt::compare< cmp<item_type> >
1220                 ,ci::opt::disposer< mock_disposer >
1221             >::type
1222         > set_type;
1223
1224         std::vector< typename set_type::value_type > data;
1225         {
1226             typename set_type::hash_tuple_type ht;
1227             set_type s( 32, 6, 0, std::move( ht ));
1228             test( s, data );
1229         }
1230     }
1231
1232     TEST_F( IntrusiveCuckooSet, refinable_vector_memberhook_ordered_cmpmix )
1233     {
1234         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
1235
1236         typedef ci::CuckooSet< item_type
1237             ,ci::cuckoo::make_traits<
1238                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1239                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1240                 > >
1241                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1242                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
1243                 ,ci::opt::less< less<item_type> >
1244                 ,ci::opt::compare< cmp<item_type> >
1245                 ,ci::opt::disposer< mock_disposer >
1246             >::type
1247         > set_type;
1248
1249         std::vector< typename set_type::value_type > data;
1250         {
1251             typename set_type::hash_tuple_type ht;
1252             set_type s( std::move( ht ));
1253             test( s, data );
1254         }
1255     }
1256
1257     TEST_F( IntrusiveCuckooSet, refinable_list_memberhook_ordered_stat )
1258     {
1259         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 0 >> item_type;
1260
1261         typedef ci::CuckooSet< item_type
1262             ,ci::cuckoo::make_traits<
1263                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1264                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1265                 > >
1266                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1267                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
1268                 ,ci::opt::less< less<item_type> >
1269                 ,ci::opt::compare< cmp<item_type> >
1270                 ,ci::opt::stat< ci::cuckoo::stat >
1271                 ,ci::opt::disposer< mock_disposer >
1272             >::type
1273         > set_type;
1274
1275         std::vector< typename set_type::value_type > data;
1276         {
1277             set_type s;
1278             test( s, data );
1279         }
1280     }
1281
1282     TEST_F( IntrusiveCuckooSet, refinable_vector_memberhook_ordered_stat )
1283     {
1284         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 0 >> item_type;
1285
1286         typedef ci::CuckooSet< item_type
1287             ,ci::cuckoo::make_traits<
1288                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1289                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1290                 > >
1291                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1292                 ,ci::opt::hash< std::tuple< hash1, hash2 > >
1293                 ,ci::opt::less< less<item_type> >
1294                 ,ci::opt::compare< cmp<item_type> >
1295                 ,ci::opt::stat< ci::cuckoo::stat >
1296                 ,ci::opt::disposer< mock_disposer >
1297             >::type
1298         > set_type;
1299
1300         std::vector< typename set_type::value_type > data;
1301         {
1302             set_type s;
1303             test( s, data );
1304         }
1305     }
1306
1307     TEST_F( IntrusiveCuckooSet, refinable_list_memberhook_unordered_storehash )
1308     {
1309         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 2 >> item_type;
1310         struct set_traits: public ci::cuckoo::traits
1311         {
1312             typedef ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1313                 ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1314                 ,ci::cuckoo::store_hash< item_type::member_type::hash_array_size >
1315             > hook;
1316             typedef ci::cuckoo::refinable<> mutex_policy;
1317             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
1318             typedef base_class::equal_to<item_type> equal_to;
1319             typedef mock_disposer disposer;
1320             typedef ci::cuckoo::stat stat;
1321         };
1322         typedef ci::CuckooSet< item_type, set_traits > set_type;
1323
1324         std::vector< typename set_type::value_type > data;
1325         {
1326             set_type s;
1327             test( s, data );
1328         }
1329     }
1330
1331     TEST_F( IntrusiveCuckooSet, refinable_vector_memberhook_unordered_storehash )
1332     {
1333         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 >> item_type;
1334         struct set_traits: public ci::cuckoo::traits
1335         {
1336             typedef ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1337                 ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1338                 ,ci::cuckoo::store_hash< item_type::member_type::hash_array_size >
1339             > hook;
1340             typedef ci::cuckoo::refinable<> mutex_policy;
1341             typedef cds::opt::hash_tuple< hash1, hash2 > hash;
1342             typedef base_class::equal_to<item_type> equal_to;
1343             typedef mock_disposer disposer;
1344             typedef ci::cuckoo::stat stat;
1345         };
1346         typedef ci::CuckooSet< item_type, set_traits > set_type;
1347
1348         std::vector< typename set_type::value_type > data;
1349         {
1350             set_type s( 32, 4 );
1351             test( s, data );
1352         }
1353     }
1354
1355     TEST_F( IntrusiveCuckooSet, refinable_list_memberhook_ordered_storehash )
1356     {
1357         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::list, 2 >> item_type;
1358
1359         typedef ci::CuckooSet< item_type
1360             ,ci::cuckoo::make_traits<
1361                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1362                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1363                     ,ci::cuckoo::store_hash< item_type::member_type::hash_array_size >
1364                 > >
1365                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1366                 ,cds::opt::hash< std::tuple< hash1, hash2 > >
1367                 ,cds::opt::less< less<item_type> >
1368                 ,cds::opt::compare< cmp<item_type> >
1369                 ,ci::opt::disposer< mock_disposer >
1370             >::type
1371         > set_type;
1372
1373         std::vector< typename set_type::value_type > data;
1374         {
1375             typename set_type::hash_tuple_type ht;
1376             set_type s( 32, 6, 0, std::move( ht ));
1377             test( s, data );
1378         }
1379     }
1380
1381     TEST_F( IntrusiveCuckooSet, refinable_vector_memberhook_ordered_storehash )
1382     {
1383         typedef base_class::member_int_item< ci::cuckoo::node< ci::cuckoo::vector<6>, 2 >> item_type;
1384
1385         typedef ci::CuckooSet< item_type
1386             ,ci::cuckoo::make_traits<
1387                 ci::opt::hook< ci::cuckoo::member_hook< offsetof( item_type, hMember ),
1388                     ci::cuckoo::probeset_type< item_type::member_type::probeset_type >
1389                     ,ci::cuckoo::store_hash< item_type::member_type::hash_array_size >
1390                 > >
1391                 ,ci::opt::mutex_policy<ci::cuckoo::refinable<>>
1392                 ,cds::opt::hash< std::tuple< hash1, hash2 > >
1393                 ,cds::opt::less< less<item_type> >
1394                 ,cds::opt::compare< cmp<item_type> >
1395                 ,ci::opt::disposer< mock_disposer >
1396             >::type
1397         > set_type;
1398
1399         std::vector< typename set_type::value_type > data;
1400         {
1401             typename set_type::hash_tuple_type ht;
1402             set_type s( std::move( ht ));
1403             test( s, data );
1404         }
1405     }
1406
1407 } // namespace