test/unit/intrusive-set/intrusive_michael_michael_nogc.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_nogc.h"
  32
  33 #include <cds/intrusive/michael_list_nogc.h>
  34 #include <cds/intrusive/michael_set_nogc.h>
  35
  36 namespace {
  37     namespace ci = cds::intrusive;
  38     typedef cds::gc::nogc gc_type;
  39
  40     class IntrusiveMichaelSet_NoGC : public cds_test::intrusive_set_nogc
  41     {
  42     protected:
  43         typedef cds_test::intrusive_set_nogc base_class;
  44
  45     protected:
  46         typedef typename base_class::base_int_item< ci::michael_list::node<gc_type>>   base_item_type;
  47         typedef typename base_class::member_int_item< ci::michael_list::node<gc_type>> member_item_type;
  48
  49         //void SetUp()
  50         //{}
  51
  52         //void TearDown()
  53         //{}
  54     };
  55
  56
  57     TEST_F( IntrusiveMichaelSet_NoGC, base_cmp )
  58     {
  59         typedef ci::MichaelList< gc_type
  60             , base_item_type
  61             ,ci::michael_list::make_traits<
  62                 ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type > > >
  63                 ,ci::opt::compare< cmp<base_item_type> >
  64                 ,ci::opt::disposer< mock_disposer >
  65             >::type
  66         > bucket_type;
  67
  68         typedef ci::MichaelHashSet< gc_type, bucket_type,
  69             ci::michael_set::make_traits<
  70                 ci::opt::hash< hash_int >
  71             >::type
  72         > set_type;
  73
  74         set_type s( kSize, 2 );
  75         test( s );
  76     }
  77
  78     TEST_F( IntrusiveMichaelSet_NoGC, base_less )
  79     {
  80         typedef ci::MichaelList< gc_type
  81             , base_item_type
  82             ,ci::michael_list::make_traits<
  83                 ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< gc_type >>>
  84                 ,ci::opt::less< less<base_item_type> >
  85                 ,ci::opt::disposer< mock_disposer >
  86             >::type
  87         > bucket_type;
  88
  89         typedef ci::MichaelHashSet< gc_type, bucket_type,
  90             ci::michael_set::make_traits<
  91                 ci::opt::hash< hash_int >
  92             >::type
  93         > set_type;
  94
  95         set_type s( kSize, 2 );
  96         test( s );
  97     }
  98
  99     TEST_F( IntrusiveMichaelSet_NoGC, base_cmpmix )
 100     {
 101         struct list_traits : public ci::michael_list::traits
 102         {
 103             typedef ci::michael_list::base_hook< ci::opt::gc<gc_type>> hook;
 104             typedef base_class::less<base_item_type> less;
 105             typedef cmp<base_item_type> compare;
 106             typedef mock_disposer disposer;
 107         };
 108         typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type;
 109
 110         struct set_traits : public ci::michael_set::traits
 111         {
 112             typedef hash_int hash;
 113             typedef simple_item_counter item_counter;
 114         };
 115         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 116
 117         set_type s( kSize, 2 );
 118         test( s );
 119     }
 120
 121     TEST_F( IntrusiveMichaelSet_NoGC, base_stat )
 122     {
 123         struct list_traits: public ci::michael_list::traits
 124         {
 125             typedef ci::michael_list::base_hook< ci::opt::gc<gc_type>> hook;
 126             typedef base_class::less<base_item_type> less;
 127             typedef mock_disposer disposer;
 128             typedef ci::michael_list::stat<> stat;
 129         };
 130         typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type;
 131
 132         struct set_traits: public ci::michael_set::traits
 133         {
 134             typedef hash_int hash;
 135             typedef simple_item_counter item_counter;
 136         };
 137         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 138
 139         set_type s( kSize, 2 );
 140         test( s );
 141     }
 142
 143     TEST_F( IntrusiveMichaelSet_NoGC, base_wrapped_stat )
 144     {
 145         struct list_traits: public ci::michael_list::traits
 146         {
 147             typedef ci::michael_list::base_hook< ci::opt::gc<gc_type>> hook;
 148             typedef base_class::less<base_item_type> less;
 149             typedef mock_disposer disposer;
 150             typedef ci::michael_list::wrapped_stat<> stat;
 151         };
 152         typedef ci::MichaelList< gc_type, base_item_type, list_traits > bucket_type;
 153
 154         struct set_traits: public ci::michael_set::traits
 155         {
 156             typedef hash_int hash;
 157             typedef simple_item_counter item_counter;
 158         };
 159         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 160
 161         set_type s( kSize, 2 );
 162         test( s );
 163     }
 164
 165     TEST_F( IntrusiveMichaelSet_NoGC, member_cmp )
 166     {
 167         typedef ci::MichaelList< gc_type
 168             ,member_item_type
 169             ,ci::michael_list::make_traits<
 170                 ci::opt::hook< ci::michael_list::member_hook<
 171                     offsetof( member_item_type, hMember ),
 172                     ci::opt::gc<gc_type>
 173                 > >
 174                 ,ci::opt::compare< cmp<member_item_type> >
 175                 ,ci::opt::disposer< mock_disposer >
 176             >::type
 177         >    bucket_type;
 178
 179         typedef ci::MichaelHashSet< gc_type, bucket_type,
 180             ci::michael_set::make_traits<
 181                 ci::opt::hash< hash_int >
 182             >::type
 183         > set_type;
 184
 185         set_type s( kSize, 2 );
 186         test( s );
 187     }
 188
 189     TEST_F( IntrusiveMichaelSet_NoGC, member_less )
 190     {
 191         typedef ci::MichaelList< gc_type
 192             , member_item_type
 193             ,ci::michael_list::make_traits<
 194                 ci::opt::hook< ci::michael_list::member_hook<
 195                     offsetof( member_item_type, hMember ),
 196                     ci::opt::gc<gc_type>
 197                 > >
 198                 ,ci::opt::less< less<member_item_type> >
 199                 ,ci::opt::disposer< mock_disposer >
 200             >::type
 201         > bucket_type;
 202
 203         typedef ci::MichaelHashSet< gc_type, bucket_type,
 204             ci::michael_set::make_traits<
 205                 ci::opt::hash< hash_int >
 206             >::type
 207         > set_type;
 208
 209         set_type s( kSize, 2 );
 210         test( s );
 211     }
 212
 213     TEST_F( IntrusiveMichaelSet_NoGC, member_cmpmix )
 214     {
 215         struct list_traits : public ci::michael_list::traits
 216         {
 217             typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc<gc_type>> hook;
 218             typedef base_class::less<member_item_type> less;
 219             typedef cmp<member_item_type> compare;
 220             typedef mock_disposer disposer;
 221         };
 222         typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type;
 223
 224         struct set_traits : public ci::michael_set::traits
 225         {
 226             typedef hash_int hash;
 227             typedef simple_item_counter item_counter;
 228         };
 229         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 230
 231         set_type s( kSize, 2 );
 232         test( s );
 233     }
 234
 235     TEST_F( IntrusiveMichaelSet_NoGC, member_stat )
 236     {
 237         struct list_traits: public ci::michael_list::traits
 238         {
 239             typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc<gc_type>> hook;
 240             typedef cmp<member_item_type> compare;
 241             typedef mock_disposer disposer;
 242             typedef ci::michael_list::stat<> stat;
 243         };
 244         typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type;
 245
 246         struct set_traits: public ci::michael_set::traits
 247         {
 248             typedef hash_int hash;
 249             typedef simple_item_counter item_counter;
 250         };
 251         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 252
 253         set_type s( kSize, 2 );
 254         test( s );
 255     }
 256
 257     TEST_F( IntrusiveMichaelSet_NoGC, member_wrapped_stat )
 258     {
 259         struct list_traits: public ci::michael_list::traits
 260         {
 261             typedef ci::michael_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc<gc_type>> hook;
 262             typedef cmp<member_item_type> compare;
 263             typedef mock_disposer disposer;
 264             typedef ci::michael_list::wrapped_stat<> stat;
 265         };
 266         typedef ci::MichaelList< gc_type, member_item_type, list_traits > bucket_type;
 267
 268         struct set_traits: public ci::michael_set::traits
 269         {
 270             typedef hash_int hash;
 271             typedef simple_item_counter item_counter;
 272         };
 273         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 274
 275         set_type s( kSize, 2 );
 276         test( s );
 277     }
 278
 279 } // namespace