tests/test-hdr/set/hdr_intrusive_cuckoo_refinable_set.cpp

   1 //$$CDS-header$$
   2
   3 #include "set/hdr_intrusive_cuckoo_set.h"
   4 #include <cds/intrusive/cuckoo_set.h>
   5
   6 #include "set/intrusive_cuckoo_set_common.h"
   7 #include "../unit/print_cuckoo_stat.h"
   8
   9 namespace set {
  10
  11     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_equal()
  12     {
  13         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
  14         typedef ci::CuckooSet< item_type
  15             ,ci::cuckoo::make_traits<
  16                 co::hash< std::tuple< hash1, hash2 > >
  17                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  18                 ,co::equal_to< equal_to<item_type> >
  19             >::type
  20         > set_type;
  21
  22         test_cuckoo<set_type>();
  23     }
  24
  25     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_equal()
  26     {
  27         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > >  item_type;
  28
  29         typedef ci::CuckooSet< item_type
  30             ,ci::cuckoo::make_traits<
  31                 ci::opt::hook< ci::cuckoo::base_hook<
  32                     ci::cuckoo::probeset_type< item_type::probeset_type >
  33                 > >
  34                 ,co::hash< std::tuple< hash1, hash2 > >
  35                 ,co::equal_to< equal_to<item_type> >
  36                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  37             >::type
  38         > set_type;
  39
  40         test_cuckoo<set_type>();
  41     }
  42
  43     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_cmp()
  44     {
  45         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
  46
  47         typedef ci::CuckooSet< item_type
  48             ,ci::cuckoo::make_traits<
  49                 ci::opt::hook< ci::cuckoo::base_hook<
  50                     ci::cuckoo::probeset_type< item_type::probeset_type >
  51                 > >
  52                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  53                 ,co::hash< std::tuple< hash1, hash2 > >
  54                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
  55             >::type
  56         > set_type;
  57
  58         test_cuckoo<set_type>();
  59     }
  60
  61     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmp()
  62     {
  63         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > >  item_type;
  64
  65         typedef ci::CuckooSet< item_type
  66             ,ci::cuckoo::make_traits<
  67                 ci::opt::hook< ci::cuckoo::base_hook<
  68                     ci::cuckoo::probeset_type< item_type::probeset_type >
  69                 > >
  70                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  71                 ,co::hash< std::tuple< hash1, hash2 > >
  72                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
  73             >::type
  74         > set_type;
  75
  76         test_cuckoo<set_type>();
  77     }
  78
  79     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_less()
  80     {
  81         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
  82
  83         typedef ci::CuckooSet< item_type
  84             ,ci::cuckoo::make_traits<
  85                 ci::opt::hook< ci::cuckoo::base_hook<
  86                     ci::cuckoo::probeset_type< item_type::probeset_type >
  87                 > >
  88                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  89                 ,co::hash< std::tuple< hash1, hash2 > >
  90                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
  91             >::type
  92         > set_type;
  93
  94         test_cuckoo<set_type>();
  95     }
  96
  97     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_less()
  98     {
  99         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > >  item_type;
 100
 101         typedef ci::CuckooSet< item_type
 102             ,ci::cuckoo::make_traits<
 103                 ci::opt::hook< ci::cuckoo::base_hook<
 104                     ci::cuckoo::probeset_type< item_type::probeset_type >
 105                 > >
 106                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 107                 ,co::hash< std::tuple< hash1, hash2 > >
 108                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 109             >::type
 110         > set_type;
 111
 112         test_cuckoo<set_type>();
 113     }
 114
 115     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_cmpmix()
 116     {
 117         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
 118
 119         typedef ci::CuckooSet< item_type
 120             ,ci::cuckoo::make_traits<
 121                 ci::opt::hook< ci::cuckoo::base_hook<
 122                     ci::cuckoo::probeset_type< item_type::probeset_type >
 123                 > >
 124                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 125                 ,co::hash< std::tuple< hash1, hash2 > >
 126                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 127                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 128             >::type
 129         > set_type;
 130
 131         test_cuckoo<set_type>();
 132     }
 133
 134     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmpmix()
 135     {
 136         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 > >  item_type;
 137
 138         typedef ci::CuckooSet< item_type
 139             ,ci::cuckoo::make_traits<
 140                 ci::opt::hook< ci::cuckoo::base_hook<
 141                     ci::cuckoo::probeset_type< item_type::probeset_type >
 142                 > >
 143                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 144                 ,co::hash< std::tuple< hash1, hash2 > >
 145                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 146                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 147             >::type
 148         > set_type;
 149
 150         test_cuckoo<set_type>();
 151     }
 152
 153     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmpmix_stat()
 154     {
 155         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 > >  item_type;
 156
 157         typedef ci::CuckooSet< item_type
 158             ,ci::cuckoo::make_traits<
 159                 ci::opt::hook< ci::cuckoo::base_hook<
 160                     ci::cuckoo::probeset_type< item_type::probeset_type >
 161                 > >
 162                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 163                 ,co::hash< std::tuple< hash1, hash2 > >
 164                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 165                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 166                 ,co::stat< ci::cuckoo::stat >
 167             >::type
 168         > set_type;
 169
 170         unsigned int nProbesetSize = set_type::node_type::probeset_size ? set_type::node_type::probeset_size : 4;
 171         set_type s( 256, nProbesetSize, nProbesetSize / 2 );
 172         test_with( s );
 173         CPPUNIT_MSG( s.statistics() << s.mutex_policy_statistics() );
 174     }
 175
 176
 177     // base hook, store hash
 178     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_equal_storehash()
 179     {
 180         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 2 > >  item_type;
 181         typedef ci::CuckooSet< item_type
 182             ,ci::cuckoo::make_traits<
 183                 ci::opt::hook< ci::cuckoo::base_hook<
 184                     ci::cuckoo::probeset_type< item_type::probeset_type >
 185                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 186                 > >
 187                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 188                 ,co::hash< std::tuple< hash1, hash2 > >
 189                 ,co::equal_to< equal_to<item_type> >
 190             >::type
 191         > set_type;
 192
 193         test_cuckoo<set_type>();
 194     }
 195
 196     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_equal_storehash()
 197     {
 198         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > >  item_type;
 199
 200         typedef ci::CuckooSet< item_type
 201             ,ci::cuckoo::make_traits<
 202                 ci::opt::hook< ci::cuckoo::base_hook<
 203                     ci::cuckoo::probeset_type< item_type::probeset_type >
 204                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 205                 > >
 206                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 207                 ,co::hash< std::tuple< hash1, hash2 > >
 208                 ,co::equal_to< equal_to<item_type> >
 209             >::type
 210         > set_type;
 211
 212         test_cuckoo<set_type>();
 213     }
 214
 215     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_cmp_storehash()
 216     {
 217         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 2 > >  item_type;
 218
 219         typedef ci::CuckooSet< item_type
 220             ,ci::cuckoo::make_traits<
 221                 ci::opt::hook< ci::cuckoo::base_hook<
 222                     ci::cuckoo::probeset_type< item_type::probeset_type >
 223                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 224                 > >
 225                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 226                 ,co::hash< std::tuple< hash1, hash2 > >
 227                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 228             >::type
 229         > set_type;
 230
 231         test_cuckoo<set_type>();
 232     }
 233
 234     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmp_storehash()
 235     {
 236         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > >  item_type;
 237
 238         typedef ci::CuckooSet< item_type
 239             ,ci::cuckoo::make_traits<
 240                 ci::opt::hook< ci::cuckoo::base_hook<
 241                     ci::cuckoo::probeset_type< item_type::probeset_type >
 242                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 243                 > >
 244                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 245                 ,co::hash< std::tuple< hash1, hash2 > >
 246                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 247             >::type
 248         > set_type;
 249
 250         test_cuckoo<set_type>();
 251     }
 252
 253     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_less_storehash()
 254     {
 255         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 2 > >  item_type;
 256
 257         typedef ci::CuckooSet< item_type
 258             ,ci::cuckoo::make_traits<
 259                 ci::opt::hook< ci::cuckoo::base_hook<
 260                     ci::cuckoo::probeset_type< item_type::probeset_type >
 261                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 262                 > >
 263                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 264                 ,co::hash< std::tuple< hash1, hash2 > >
 265                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 266             >::type
 267         > set_type;
 268
 269         test_cuckoo<set_type>();
 270     }
 271
 272     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_less_storehash()
 273     {
 274         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > >  item_type;
 275
 276         typedef ci::CuckooSet< item_type
 277             ,ci::cuckoo::make_traits<
 278                 ci::opt::hook< ci::cuckoo::base_hook<
 279                     ci::cuckoo::probeset_type< item_type::probeset_type >
 280                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 281                 > >
 282                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 283                 ,co::hash< std::tuple< hash1, hash2 > >
 284                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 285             >::type
 286         > set_type;
 287
 288         test_cuckoo<set_type>();
 289     }
 290
 291     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_cmpmix_storehash()
 292     {
 293         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 2 > >  item_type;
 294
 295         typedef ci::CuckooSet< item_type
 296             ,ci::cuckoo::make_traits<
 297                 ci::opt::hook< ci::cuckoo::base_hook<
 298                     ci::cuckoo::probeset_type< item_type::probeset_type >
 299                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 300                 > >
 301                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 302                 ,co::hash< std::tuple< hash1, hash2 > >
 303                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 304                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 305             >::type
 306         > set_type;
 307
 308         test_cuckoo<set_type>();
 309     }
 310
 311     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmpmix_storehash()
 312     {
 313         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 2 > >  item_type;
 314
 315         typedef ci::CuckooSet< item_type
 316             ,ci::cuckoo::make_traits<
 317                 ci::opt::hook< ci::cuckoo::base_hook<
 318                     ci::cuckoo::probeset_type< item_type::probeset_type >
 319                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 320                 > >
 321                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 322                 ,co::hash< std::tuple< hash1, hash2 > >
 323                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 324                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 325             >::type
 326         > set_type;
 327
 328         test_cuckoo<set_type>();
 329     }
 330
 331
 332     // Member hook
 333     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_equal()
 334     {
 335         typedef IntrusiveCuckooSetHdrTest::member_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
 336         typedef ci::CuckooSet< item_type
 337             ,ci::cuckoo::make_traits<
 338                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember)> >
 339                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 340                 ,co::hash< std::tuple< hash1, hash2 > >
 341                 ,co::equal_to< equal_to<item_type> >
 342             >::type
 343         > set_type;
 344
 345         test_cuckoo<set_type>();
 346     }
 347
 348     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_equal()
 349     {
 350         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > node_type;
 351         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 352
 353         typedef ci::CuckooSet< item_type
 354             ,ci::cuckoo::make_traits<
 355                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 356                     ci::cuckoo::probeset_type< node_type::probeset_type >
 357                 > >
 358                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 359                 ,co::hash< std::tuple< hash1, hash2 > >
 360                 ,co::equal_to< equal_to<item_type> >
 361             >::type
 362         > set_type;
 363
 364         test_cuckoo<set_type>();
 365     }
 366
 367     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_cmp()
 368     {
 369         typedef ci::cuckoo::node< ci::cuckoo::list, 0 > node_type;
 370         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 371
 372         typedef ci::CuckooSet< item_type
 373             ,ci::cuckoo::make_traits<
 374                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 375                     ci::cuckoo::probeset_type< node_type::probeset_type >
 376                 > >
 377                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 378                 ,co::hash< std::tuple< hash1, hash2 > >
 379                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 380             >::type
 381         > set_type;
 382
 383         test_cuckoo<set_type>();
 384     }
 385
 386     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_cmp()
 387     {
 388         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > node_type;
 389         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 390
 391         typedef ci::CuckooSet< item_type
 392             ,ci::cuckoo::make_traits<
 393                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 394                     ci::cuckoo::probeset_type< node_type::probeset_type >
 395                 > >
 396                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 397                 ,co::hash< std::tuple< hash1, hash2 > >
 398                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 399             >::type
 400         > set_type;
 401
 402         test_cuckoo<set_type>();
 403     }
 404
 405     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_less()
 406     {
 407         typedef ci::cuckoo::node< ci::cuckoo::list, 0 > node_type;
 408         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 409
 410         typedef ci::CuckooSet< item_type
 411             ,ci::cuckoo::make_traits<
 412                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 413                     ci::cuckoo::probeset_type< node_type::probeset_type >
 414                 > >
 415                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 416                 ,co::hash< std::tuple< hash1, hash2 > >
 417                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 418             >::type
 419         > set_type;
 420
 421         test_cuckoo<set_type>();
 422     }
 423
 424     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_less()
 425     {
 426         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > node_type;
 427         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 428
 429         typedef ci::CuckooSet< item_type
 430             ,ci::cuckoo::make_traits<
 431                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 432                     ci::cuckoo::probeset_type< node_type::probeset_type >
 433                 > >
 434                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 435                 ,co::hash< std::tuple< hash1, hash2 > >
 436                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 437             >::type
 438         > set_type;
 439
 440         test_cuckoo<set_type>();
 441     }
 442
 443     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_cmpmix()
 444     {
 445         typedef ci::cuckoo::node< ci::cuckoo::list, 0 > node_type;
 446         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 447
 448         typedef ci::CuckooSet< item_type
 449             ,ci::cuckoo::make_traits<
 450                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 451                     ci::cuckoo::probeset_type< node_type::probeset_type >
 452                 > >
 453                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 454                 ,co::hash< std::tuple< hash1, hash2 > >
 455                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 456                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 457             >::type
 458         > set_type;
 459
 460         test_cuckoo<set_type>();
 461     }
 462
 463     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_cmpmix()
 464     {
 465         typedef ci::cuckoo::node< ci::cuckoo::vector<8>, 0 > node_type;
 466         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 467
 468         typedef ci::CuckooSet< item_type
 469             ,ci::cuckoo::make_traits<
 470                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 471                     ci::cuckoo::probeset_type< node_type::probeset_type >
 472                 > >
 473                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 474                 ,co::hash< std::tuple< hash1, hash2 > >
 475                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 476                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 477             >::type
 478         > set_type;
 479
 480         test_cuckoo<set_type>();
 481     }
 482
 483
 484     // member hook, store hash
 485     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_equal_storehash()
 486     {
 487         typedef ci::cuckoo::node< ci::cuckoo::list, 2 > node_type;
 488         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 489         typedef ci::CuckooSet< item_type
 490             ,ci::cuckoo::make_traits<
 491                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 492                     ci::cuckoo::probeset_type< node_type::probeset_type >
 493                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 494                 > >
 495                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 496                 ,co::hash< std::tuple< hash1, hash2 > >
 497                 ,co::equal_to< equal_to<item_type> >
 498             >::type
 499         > set_type;
 500
 501         test_cuckoo<set_type>();
 502     }
 503
 504     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_equal_storehash()
 505     {
 506         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > node_type;
 507         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 508
 509         typedef ci::CuckooSet< item_type
 510             ,ci::cuckoo::make_traits<
 511                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 512                     ci::cuckoo::probeset_type< node_type::probeset_type >
 513                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 514                 > >
 515                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 516                 ,co::hash< std::tuple< hash1, hash2 > >
 517                 ,co::equal_to< equal_to<item_type> >
 518             >::type
 519         > set_type;
 520
 521         test_cuckoo<set_type>();
 522     }
 523
 524     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_cmp_storehash()
 525     {
 526         typedef ci::cuckoo::node< ci::cuckoo::list, 2 > node_type;
 527         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 528
 529         typedef ci::CuckooSet< item_type
 530             ,ci::cuckoo::make_traits<
 531                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 532                     ci::cuckoo::probeset_type< node_type::probeset_type >
 533                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 534                 > >
 535                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 536                 ,co::hash< std::tuple< hash1, hash2 > >
 537                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 538             >::type
 539         > set_type;
 540
 541         test_cuckoo<set_type>();
 542     }
 543
 544     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_cmp_storehash()
 545     {
 546         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > node_type;
 547         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 548
 549         typedef ci::CuckooSet< item_type
 550             ,ci::cuckoo::make_traits<
 551                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 552                     ci::cuckoo::probeset_type< node_type::probeset_type >
 553                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 554                 > >
 555                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 556                 ,co::hash< std::tuple< hash1, hash2 > >
 557                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 558             >::type
 559         > set_type;
 560
 561         test_cuckoo<set_type>();
 562     }
 563
 564     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_less_storehash()
 565     {
 566         typedef ci::cuckoo::node< ci::cuckoo::list, 2 > node_type;
 567         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 568
 569         typedef ci::CuckooSet< item_type
 570             ,ci::cuckoo::make_traits<
 571                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 572                     ci::cuckoo::probeset_type< node_type::probeset_type >
 573                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 574                 > >
 575                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 576                 ,co::hash< std::tuple< hash1, hash2 > >
 577                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 578             >::type
 579         > set_type;
 580
 581         test_cuckoo<set_type>();
 582     }
 583
 584     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_less_storehash()
 585     {
 586         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > node_type;
 587         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 588
 589         typedef ci::CuckooSet< item_type
 590             ,ci::cuckoo::make_traits<
 591                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 592                     ci::cuckoo::probeset_type< node_type::probeset_type >
 593                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 594                 > >
 595                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 596                 ,co::hash< std::tuple< hash1, hash2 > >
 597                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 598             >::type
 599         > set_type;
 600
 601         test_cuckoo<set_type>();
 602     }
 603
 604     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_cmpmix_storehash()
 605     {
 606         typedef ci::cuckoo::node< ci::cuckoo::list, 2 > node_type;
 607         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 608
 609         typedef ci::CuckooSet< item_type
 610             ,ci::cuckoo::make_traits<
 611                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 612                     ci::cuckoo::probeset_type< node_type::probeset_type >
 613                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 614                 > >
 615                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 616                 ,co::hash< std::tuple< hash1, hash2 > >
 617                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 618                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 619             >::type
 620         > set_type;
 621
 622         test_cuckoo<set_type>();
 623     }
 624
 625     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_cmpmix_storehash()
 626     {
 627         typedef ci::cuckoo::node< ci::cuckoo::vector<8>, 2 > node_type;
 628         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 629
 630         typedef ci::CuckooSet< item_type
 631             ,ci::cuckoo::make_traits<
 632                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 633                     ci::cuckoo::probeset_type< node_type::probeset_type >
 634                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 635                 > >
 636                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 637                 ,co::hash< std::tuple< hash1, hash2 > >
 638                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 639                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 640             >::type
 641         > set_type;
 642
 643         test_cuckoo<set_type>();
 644     }
 645
 646 }   // namespace set