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