test/stress/sequential/sequential-set/set_type_striped.h

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017
   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 #ifndef CDSUNIT_SET_TYPE_STRIPED_H
  32 #define CDSUNIT_SET_TYPE_STRIPED_H
  33
  34 #include "set_type.h"
  35
  36 #include <cds/container/striped_set/std_list.h>
  37 #include <cds/container/striped_set/std_vector.h>
  38 #include <cds/container/striped_set/std_set.h>
  39 #include <cds/container/striped_set/std_hash_set.h>
  40 #include <cds/container/striped_set/boost_unordered_set.h>
  41
  42 #include <boost/version.hpp>
  43 #if BOOST_VERSION >= 104800
  44 #   include <cds/container/striped_set/boost_slist.h>
  45 #   include <cds/container/striped_set/boost_list.h>
  46 #   include <cds/container/striped_set/boost_vector.h>
  47 #   include <cds/container/striped_set/boost_stable_vector.h>
  48 #   include <cds/container/striped_set/boost_set.h>
  49 #   include <cds/container/striped_set/boost_flat_set.h>
  50 #endif
  51 #include <cds/container/striped_set.h>
  52
  53 namespace set {
  54
  55     struct tag_StripedSet;
  56
  57     template <typename Key, typename Val>
  58     struct set_type< tag_StripedSet, Key, Val >: public set_type_base< Key, Val >
  59     {
  60         typedef set_type_base< Key, Val > base_class;
  61         typedef typename base_class::key_val key_val;
  62         typedef typename base_class::compare compare;
  63         typedef typename base_class::less less;
  64         typedef typename base_class::equal_to equal_to;
  65         typedef typename base_class::hash hash;
  66         typedef typename base_class::hash2 hash2;
  67
  68
  69         // ***************************************************************************
  70         // StripedSet
  71
  72         // for sequential containers
  73         template <class BucketEntry, typename... Options>
  74         class StripedHashSet_seq:
  75             public cc::StripedSet< BucketEntry,
  76                 co::mutex_policy< cc::striped_set::striping<> >
  77                 ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
  78                 , Options...
  79             >
  80         {
  81             typedef cc::StripedSet< BucketEntry,
  82                 co::mutex_policy< cc::striped_set::striping<> >
  83                 ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
  84                 , Options...
  85             > base_class;
  86             typedef typename base_class::resizing_policy resizing_policy_t;
  87
  88             resizing_policy_t   m_placeHolder;
  89         public:
  90             template <class Config>
  91             StripedHashSet_seq( Config const& cfg )
  92                 : base_class( cfg.s_nSetSize / cfg.s_nLoadFactor / 16, *(new(&m_placeHolder) resizing_policy_t( cfg.s_nLoadFactor )))
  93             {}
  94
  95             empty_stat statistics() const
  96             {
  97                 return empty_stat();
  98             }
  99
 100             /*
 101             template <typename Q, typename Less>
 102             bool erase_with( Q const& v, Less pred )
 103             {
 104                 return base_class::erase( v );
 105             }
 106             */
 107
 108             // for testing
 109             static CDS_CONSTEXPR bool const c_bExtractSupported = false;
 110             static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
 111             static CDS_CONSTEXPR bool const c_bEraseExactKey = false;
 112         };
 113
 114         template <class BucketEntry, typename... Options>
 115         class StripedHashSet_seq_rational:
 116             public cc::StripedSet< BucketEntry,
 117                 co::mutex_policy< cc::striped_set::striping<> >
 118                 ,co::resizing_policy<cc::striped_set::rational_load_factor_resizing<0> >
 119                 , Options...
 120             >
 121         {
 122             typedef cc::StripedSet< BucketEntry,
 123                 co::mutex_policy< cc::striped_set::striping<> >
 124                 ,co::resizing_policy<cc::striped_set::rational_load_factor_resizing<0> >
 125                 , Options...
 126             > base_class;
 127             typedef typename base_class::resizing_policy resizing_policy_t;
 128
 129             resizing_policy_t   m_placeHolder;
 130         public:
 131             template <class Config>
 132             StripedHashSet_seq_rational( Config const& cfg ) // LoadFactor = 1 / nDenominator
 133                 : base_class( cfg.s_nSetSize / cfg.s_nLoadFactor / 16, *(new(&m_placeHolder) resizing_policy_t( 1, cfg.s_nLoadFactor )))
 134             {}
 135
 136             empty_stat statistics() const
 137             {
 138                 return empty_stat();
 139             }
 140
 141             /*
 142             template <typename Q, typename Less>
 143             bool erase_with( Q const& v, Less pred )
 144             {
 145                 return base_class::erase( v );
 146             }
 147             */
 148
 149             // for testing
 150             static CDS_CONSTEXPR bool const c_bExtractSupported = false;
 151             static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
 152             static CDS_CONSTEXPR bool const c_bEraseExactKey = false;
 153         };
 154
 155         // for non-sequential ordered containers
 156         template <class BucketEntry, typename... Options>
 157         class StripedHashSet_ord:
 158             public cc::StripedSet< BucketEntry,
 159                 co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
 160                 ,co::mutex_policy< cc::striped_set::striping<> >
 161                 , Options...
 162             >
 163         {
 164             typedef cc::StripedSet< BucketEntry,
 165                co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
 166                 ,co::mutex_policy< cc::striped_set::striping<> >
 167                 , Options...
 168             > base_class;
 169             typedef typename base_class::resizing_policy resizing_policy_t;
 170
 171             resizing_policy_t   m_placeHolder;
 172         public:
 173             template <class Config>
 174             StripedHashSet_ord( Config const& cfg )
 175                 : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( cfg.s_nMaxLoadFactor * 1024 )))
 176             {}
 177
 178             empty_stat statistics() const
 179             {
 180                 return empty_stat();
 181             }
 182
 183             // for testing
 184             static CDS_CONSTEXPR bool const c_bExtractSupported = false;
 185             static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false;
 186             static CDS_CONSTEXPR bool const c_bEraseExactKey = false;
 187         };
 188
 189         template <class BucketEntry, typename... Options>
 190         class StripedHashSet_ord_rational:
 191             public cc::StripedSet< BucketEntry,
 192                 co::resizing_policy<cc::striped_set::rational_load_factor_resizing<0> >
 193                 ,co::mutex_policy< cc::striped_set::striping<> >
 194                 , Options...
 195             >
 196         {
 197             typedef cc::StripedSet< BucketEntry,
 198                co::resizing_policy<cc::striped_set::rational_load_factor_resizing<0> >
 199                 ,co::mutex_policy< cc::striped_set::striping<> >
 200                 , Options...
 201             > base_class;
 202             typedef typename base_class::resizing_policy resizing_policy_t;
 203
 204             resizing_policy_t   m_placeHolder;
 205         public:
 206             template <class Config>
 207             StripedHashSet_ord_rational( Config const& cfg ) // LoadFactor = 1 / nDenominator
 208                 : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( 1024, cfg.s_nLoadFactor )))
 209             {}
 210
 211             empty_stat statistics() const
 212             {
 213                 return empty_stat();
 214             }
 215
 216             // for testing
 217             static CDS_CONSTEXPR bool const c_bExtractSupported = false;
 218             static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
 219             static CDS_CONSTEXPR bool const c_bEraseExactKey = false;
 220         };
 221
 222         typedef StripedHashSet_seq<
 223             std::list< key_val >
 224             , co::hash< hash2 >
 225             , co::less< less >
 226         > StripedSet_list;
 227
 228         typedef StripedHashSet_seq_rational<
 229             std::list< key_val >
 230             , co::hash< hash2 >
 231             , co::less< less >
 232         > StripedSet_rational_list;
 233
 234         typedef StripedHashSet_seq<
 235             std::vector< key_val >
 236             , co::hash< hash2 >
 237             , co::less< less >
 238         > StripedSet_vector;
 239
 240         typedef StripedHashSet_seq_rational<
 241             std::vector< key_val >
 242             , co::hash< hash2 >
 243             , co::less< less >
 244         > StripedSet_rational_vector;
 245
 246 #if BOOST_VERSION >= 104800
 247         typedef StripedHashSet_seq<
 248             boost::container::slist< key_val >
 249             , co::hash< hash2 >
 250             , co::less< less >
 251         > StripedSet_boost_slist;
 252
 253         typedef StripedHashSet_seq_rational<
 254             boost::container::slist< key_val >
 255             , co::hash< hash2 >
 256             , co::less< less >
 257         > StripedSet_rational_boost_slist;
 258
 259         typedef StripedHashSet_seq<
 260             boost::container::list< key_val >
 261             , co::hash< hash2 >
 262             , co::less< less >
 263         > StripedSet_boost_list;
 264
 265         typedef StripedHashSet_seq_rational<
 266             boost::container::list< key_val >
 267             , co::hash< hash2 >
 268             , co::less< less >
 269         > StripedSet_rational_boost_list;
 270
 271         typedef StripedHashSet_seq<
 272             boost::container::vector< key_val >
 273             , co::hash< hash2 >
 274             , co::less< less >
 275         > StripedSet_boost_vector;
 276
 277         typedef StripedHashSet_seq_rational<
 278             boost::container::vector< key_val >
 279             , co::hash< hash2 >
 280             , co::less< less >
 281         > StripedSet_rational_boost_vector;
 282
 283         typedef StripedHashSet_seq<
 284             boost::container::stable_vector< key_val >
 285             , co::hash< hash2 >
 286             , co::less< less >
 287         > StripedSet_boost_stable_vector;
 288
 289         typedef StripedHashSet_seq_rational<
 290             boost::container::stable_vector< key_val >
 291             , co::hash< hash2 >
 292             , co::less< less >
 293         > StripedSet_rational_boost_stable_vector;
 294 #endif
 295
 296         typedef StripedHashSet_ord<
 297             std::set< key_val, less >
 298             , co::hash< hash2 >
 299         > StripedSet_set;
 300
 301         typedef StripedHashSet_ord_rational<
 302             std::set< key_val, less >
 303             , co::hash< hash2 >
 304         > StripedSet_rational_set;
 305
 306         typedef StripedHashSet_ord<
 307             std::unordered_set< key_val, hash, equal_to >
 308             , co::hash< hash2 >
 309         > StripedSet_hashset;
 310
 311         typedef StripedHashSet_ord_rational<
 312             std::unordered_set< key_val, hash, equal_to >
 313             , co::hash< hash2 >
 314         > StripedSet_rational_hashset;
 315
 316 #if BOOST_VERSION >= 104800
 317         typedef StripedHashSet_ord<
 318             boost::container::set< key_val, less >
 319             , co::hash< hash2 >
 320         > StripedSet_boost_set;
 321
 322         typedef StripedHashSet_ord_rational<
 323             boost::container::set< key_val, less >
 324             , co::hash< hash2 >
 325         > StripedSet_rational_boost_set;
 326
 327         typedef StripedHashSet_ord<
 328             boost::container::flat_set< key_val, less >
 329             , co::hash< hash2 >
 330         > StripedSet_boost_flat_set;
 331
 332         typedef StripedHashSet_ord_rational<
 333             boost::container::flat_set< key_val, less >
 334             , co::hash< hash2 >
 335         > StripedSet_rational_boost_flat_set;
 336 #endif
 337
 338         typedef StripedHashSet_ord<
 339             boost::unordered_set< key_val, hash, equal_to >
 340             , co::hash< hash2 >
 341         > StripedSet_boost_unordered_set;
 342
 343         typedef StripedHashSet_ord_rational<
 344             boost::unordered_set< key_val, hash, equal_to >
 345             , co::hash< hash2 >
 346         > StripedSet_rational_boost_unordered_set;
 347
 348
 349         // ***************************************************************************
 350         // RefinableSet
 351
 352         // for sequential containers
 353         template <class BucketEntry, typename... Options>
 354         class RefinableHashSet_seq:
 355             public cc::StripedSet< BucketEntry,
 356             co::mutex_policy< cc::striped_set::refinable<> >
 357             ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
 358             , Options...
 359             >
 360         {
 361             typedef cc::StripedSet< BucketEntry,
 362                 co::mutex_policy< cc::striped_set::refinable<> >
 363                 ,co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
 364                 , Options...
 365             > base_class;
 366             typedef typename base_class::resizing_policy resizing_policy_t;
 367
 368             resizing_policy_t   m_placeHolder;
 369         public:
 370             template <class Config>
 371             RefinableHashSet_seq( Config const& cfg )
 372                 : base_class( cfg.s_nSetSize / cfg.s_nLoadFactor / 16, *(new(&m_placeHolder) resizing_policy_t( cfg.s_nLoadFactor )))
 373             {}
 374
 375             empty_stat statistics() const
 376             {
 377                 return empty_stat();
 378             }
 379
 380             /*
 381             template <typename Q, typename Less>
 382             bool erase_with( Q const& v, Less pred )
 383             {
 384                 return base_class::erase( v );
 385             }
 386             */
 387
 388             // for testing
 389             static CDS_CONSTEXPR bool const c_bExtractSupported = false;
 390             static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
 391         };
 392
 393         template <class BucketEntry, typename... Options>
 394         class RefinableHashSet_seq_rational:
 395             public cc::StripedSet< BucketEntry,
 396             co::mutex_policy< cc::striped_set::refinable<> >
 397             ,co::resizing_policy<cc::striped_set::rational_load_factor_resizing<0> >
 398             , Options...
 399             >
 400         {
 401             typedef cc::StripedSet< BucketEntry,
 402                 co::mutex_policy< cc::striped_set::refinable<> >
 403                 ,co::resizing_policy<cc::striped_set::rational_load_factor_resizing<0> >
 404                 , Options...
 405             > base_class;
 406             typedef typename base_class::resizing_policy resizing_policy_t;
 407
 408             resizing_policy_t   m_placeHolder;
 409         public:
 410             template <class Config>
 411             RefinableHashSet_seq_rational( Config const& cfg ) // LoadFactor = 1 / nDenominator
 412                 : base_class( cfg.s_nSetSize / cfg.s_nLoadFactor / 16, *(new(&m_placeHolder) resizing_policy_t( 1, cfg.s_nLoadFactor )))
 413             {}
 414
 415             empty_stat statistics() const
 416             {
 417                 return empty_stat();
 418             }
 419
 420             // for testing
 421             static CDS_CONSTEXPR bool const c_bExtractSupported = false;
 422             static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
 423         };
 424
 425         // for non-sequential ordered containers
 426         template <class BucketEntry, typename... Options>
 427         class RefinableHashSet_ord:
 428             public cc::StripedSet< BucketEntry,
 429                 co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
 430                 ,co::mutex_policy< cc::striped_set::refinable<> >
 431                 , Options...
 432             >
 433         {
 434             typedef cc::StripedSet< BucketEntry,
 435                 co::resizing_policy<cc::striped_set::load_factor_resizing<0> >
 436                 ,co::mutex_policy< cc::striped_set::refinable<> >
 437                 , Options...
 438             > base_class;
 439             typedef typename base_class::resizing_policy resizing_policy_t;
 440
 441             resizing_policy_t   m_placeHolder;
 442         public:
 443             template <class Config>
 444             RefinableHashSet_ord( Config const& cfg )
 445                 : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( cfg.s_nMaxLoadFactor * 1024 )))
 446             {}
 447
 448             empty_stat statistics() const
 449             {
 450                 return empty_stat();
 451             }
 452
 453             // for testing
 454             static CDS_CONSTEXPR bool const c_bExtractSupported = false;
 455             static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false;
 456         };
 457
 458         template <class BucketEntry, typename... Options>
 459         class RefinableHashSet_ord_rational:
 460             public cc::StripedSet< BucketEntry,
 461                 co::resizing_policy<cc::striped_set::rational_load_factor_resizing<0> >
 462                 ,co::mutex_policy< cc::striped_set::refinable<> >
 463                 , Options...
 464             >
 465         {
 466             typedef cc::StripedSet< BucketEntry,
 467                 co::resizing_policy<cc::striped_set::rational_load_factor_resizing<0> >
 468                 ,co::mutex_policy< cc::striped_set::refinable<> >
 469                 , Options...
 470             > base_class;
 471             typedef typename base_class::resizing_policy resizing_policy_t;
 472
 473             resizing_policy_t   m_placeHolder;
 474         public:
 475             template <class Config>
 476             RefinableHashSet_ord_rational( Config const& cfg ) // LoadFactor = 1 / nDenominator
 477                 : base_class( 0, *(new(&m_placeHolder) resizing_policy_t( 1024, cfg.s_nLoadFactor )))
 478             {}
 479
 480             empty_stat statistics() const
 481             {
 482                 return empty_stat();
 483             }
 484
 485             // for testing
 486             static CDS_CONSTEXPR bool const c_bExtractSupported = false;
 487             static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
 488         };
 489
 490         typedef RefinableHashSet_seq<
 491             std::list< key_val >
 492             , co::hash< hash2 >
 493             , co::less< less >
 494         > RefinableSet_list;
 495
 496         typedef RefinableHashSet_seq_rational<
 497             std::list< key_val >
 498             , co::hash< hash2 >
 499             , co::less< less >
 500         > RefinableSet_rational_list;
 501
 502         typedef RefinableHashSet_seq<
 503             std::vector< key_val >
 504             , co::hash< hash2 >
 505             , co::less< less >
 506         > RefinableSet_vector;
 507
 508         typedef RefinableHashSet_seq_rational<
 509             std::vector< key_val >
 510             , co::hash< hash2 >
 511             , co::less< less >
 512         > RefinableSet_rational_vector;
 513
 514 #if BOOST_VERSION >= 104800
 515         typedef RefinableHashSet_seq<
 516             boost::container::slist< key_val >
 517             , co::hash< hash2 >
 518             , co::less< less >
 519         > RefinableSet_boost_slist;
 520
 521         typedef RefinableHashSet_seq_rational<
 522             boost::container::slist< key_val >
 523             , co::hash< hash2 >
 524             , co::less< less >
 525         > RefinableSet_rational_boost_slist;
 526
 527         typedef RefinableHashSet_seq<
 528             boost::container::list< key_val >
 529             , co::hash< hash2 >
 530             , co::less< less >
 531         > RefinableSet_boost_list;
 532
 533         typedef RefinableHashSet_seq_rational<
 534             boost::container::list< key_val >
 535             , co::hash< hash2 >
 536             , co::less< less >
 537         > RefinableSet_rational_boost_list;
 538
 539         typedef RefinableHashSet_seq<
 540             boost::container::vector< key_val >
 541             , co::hash< hash2 >
 542             , co::less< less >
 543         > RefinableSet_boost_vector;
 544
 545         typedef RefinableHashSet_seq_rational<
 546             boost::container::vector< key_val >
 547             , co::hash< hash2 >
 548             , co::less< less >
 549         > RefinableSet_rational_boost_vector;
 550
 551         typedef RefinableHashSet_seq<
 552             boost::container::stable_vector< key_val >
 553             , co::hash< hash2 >
 554             , co::less< less >
 555         > RefinableSet_boost_stable_vector;
 556
 557         typedef RefinableHashSet_seq_rational<
 558             boost::container::stable_vector< key_val >
 559             , co::hash< hash2 >
 560             , co::less< less >
 561         > RefinableSet_rational_boost_stable_vector;
 562 #endif
 563
 564         typedef RefinableHashSet_ord<
 565             std::set< key_val, less >
 566             , co::hash< hash2 >
 567         > RefinableSet_set;
 568
 569         typedef RefinableHashSet_ord_rational<
 570             std::set< key_val, less >
 571             , co::hash< hash2 >
 572         > RefinableSet_rational_set;
 573
 574         typedef RefinableHashSet_ord<
 575             std::unordered_set< key_val, hash, equal_to >
 576             , co::hash< hash2 >
 577         > RefinableSet_hashset;
 578
 579         typedef RefinableHashSet_ord_rational<
 580             std::unordered_set< key_val, hash, equal_to >
 581             , co::hash< hash2 >
 582         > RefinableSet_rational_hashset;
 583
 584 #if BOOST_VERSION >= 104800
 585         typedef RefinableHashSet_ord<
 586             boost::container::set< key_val, less >
 587             , co::hash< hash2 >
 588         > RefinableSet_boost_set;
 589
 590         typedef RefinableHashSet_ord_rational<
 591             boost::container::set< key_val, less >
 592             , co::hash< hash2 >
 593         > RefinableSet_rational_boost_set;
 594
 595         typedef RefinableHashSet_ord<
 596             boost::container::flat_set< key_val, less >
 597             , co::hash< hash2 >
 598         > RefinableSet_boost_flat_set;
 599
 600         typedef RefinableHashSet_ord_rational<
 601             boost::container::flat_set< key_val, less >
 602             , co::hash< hash2 >
 603         > RefinableSet_rational_boost_flat_set;
 604 #endif
 605
 606         typedef RefinableHashSet_ord<
 607             boost::unordered_set< key_val, hash, equal_to >
 608             , co::hash< hash2 >
 609         > RefinableSet_boost_unordered_set;
 610
 611         typedef RefinableHashSet_ord_rational<
 612             boost::unordered_set< key_val, hash, equal_to >
 613             , co::hash< hash2 >
 614         > RefinableSet_rational_boost_unordered_set;
 615     };
 616
 617 } // namespace set
 618
 619 #define CDSSTRESS_StripedSet_case( fixture, test_case, striped_set_type, key_type, value_type ) \
 620     TEST_P( fixture, striped_set_type ) \
 621     { \
 622         typedef set::set_type< tag_StripedSet, key_type, value_type >::striped_set_type set_type; \
 623         test_case<set_type>(); \
 624     }
 625
 626 #define CDSSTRESS_StripedSet( fixture, test_case, key_type, value_type ) \
 627     CDSSTRESS_StripedSet_case( fixture, test_case, StripedSet_list,                 key_type, value_type ) \
 628     CDSSTRESS_StripedSet_case( fixture, test_case, StripedSet_rational_list,        key_type, value_type ) \
 629     CDSSTRESS_StripedSet_case( fixture, test_case, StripedSet_vector,               key_type, value_type ) \
 630     CDSSTRESS_StripedSet_case( fixture, test_case, StripedSet_rational_vector,      key_type, value_type ) \
 631     CDSSTRESS_StripedSet_case( fixture, test_case, StripedSet_set,                  key_type, value_type ) \
 632     CDSSTRESS_StripedSet_case( fixture, test_case, StripedSet_rational_set,         key_type, value_type ) \
 633     CDSSTRESS_StripedSet_case( fixture, test_case, StripedSet_hashset,              key_type, value_type ) \
 634     CDSSTRESS_StripedSet_case( fixture, test_case, StripedSet_rational_hashset,     key_type, value_type ) \
 635     CDSSTRESS_StripedSet_case( fixture, test_case, RefinableSet_list,               key_type, value_type ) \
 636     CDSSTRESS_StripedSet_case( fixture, test_case, RefinableSet_rational_list,      key_type, value_type ) \
 637     CDSSTRESS_StripedSet_case( fixture, test_case, RefinableSet_vector,             key_type, value_type ) \
 638     CDSSTRESS_StripedSet_case( fixture, test_case, RefinableSet_rational_vector,    key_type, value_type ) \
 639     CDSSTRESS_StripedSet_case( fixture, test_case, RefinableSet_set,                key_type, value_type ) \
 640     CDSSTRESS_StripedSet_case( fixture, test_case, RefinableSet_rational_set,       key_type, value_type ) \
 641     CDSSTRESS_StripedSet_case( fixture, test_case, RefinableSet_hashset,            key_type, value_type ) \
 642     CDSSTRESS_StripedSet_case( fixture, test_case, RefinableSet_rational_hashset,   key_type, value_type )
 643
 644 #endif // #ifndef CDSUNIT_SET_TYPE_STRIPED_H