tests/test-hdr/set/hdr_cuckoo_set.cpp

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