test/unit/queue/test_intrusive_bounded_queue.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-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 #ifndef CDSUNIT_QUEUE_TEST_INTRUSIVE_BOUNDED_QUEUE_H
  32 #define CDSUNIT_QUEUE_TEST_INTRUSIVE_BOUNDED_QUEUE_H
  33
  34 #include <cds_test/check_size.h>
  35 #include <vector>
  36
  37 namespace cds_test {
  38
  39     class intrusive_bounded_queue : public ::testing::Test
  40     {
  41     protected:
  42         struct item {
  43             int nVal;
  44             int nDisposeCount;
  45
  46             item()
  47                 : nDisposeCount( 0 )
  48             {}
  49         };
  50
  51     protected:
  52         template <typename Queue>
  53         void test( Queue& q )
  54         {
  55             typedef typename Queue::value_type value_type;
  56             value_type it;
  57
  58             const size_t nSize = q.capacity();
  59
  60             ASSERT_TRUE( q.empty() );
  61             ASSERT_CONTAINER_SIZE( q, 0 );
  62
  63             std::vector< value_type > arr;
  64             arr.resize( nSize );
  65             for ( size_t i = 0; i < nSize; ++i )
  66                 arr[i].nVal = static_cast<int>(i);
  67
  68             // push
  69             for ( auto& i : arr ) {
  70                 if ( i.nVal & 1 ) {
  71                     ASSERT_TRUE( q.push( i ));
  72                 }
  73                 else {
  74                     ASSERT_TRUE( q.enqueue( i ));
  75                 }
  76                 ASSERT_CONTAINER_SIZE( q, i.nVal + 1 );
  77                 ASSERT_FALSE( q.empty() );
  78             }
  79
  80             ASSERT_CONTAINER_SIZE( q, q.capacity() );
  81
  82             // pop
  83             int val = 0;
  84             while ( !q.empty() ) {
  85                 value_type * v;
  86                 if ( val & 1 )
  87                     v = q.pop();
  88                 else
  89                     v = q.dequeue();
  90
  91                 ASSERT_TRUE( v != nullptr );
  92                 ASSERT_EQ( v->nVal, val );
  93                 ++val;
  94                 ASSERT_CONTAINER_SIZE( q, nSize - static_cast<size_t>( val ));
  95             }
  96             ASSERT_EQ( val, static_cast<int>( nSize ));
  97
  98             ASSERT_TRUE( q.empty() );
  99             ASSERT_CONTAINER_SIZE( q, 0 );
 100
 101             // pop from empty queue
 102             {
 103                 value_type * v = q.pop();
 104                 ASSERT_TRUE( v == nullptr );
 105                 ASSERT_TRUE( q.empty() );
 106                 ASSERT_CONTAINER_SIZE( q, 0 );
 107             }
 108
 109             // clear
 110             for ( auto& i : arr ) {
 111                 ASSERT_TRUE( q.push( i ) );
 112             }
 113             ASSERT_FALSE( q.empty() );
 114             ASSERT_CONTAINER_SIZE( q, q.capacity() );
 115             q.clear();
 116             ASSERT_TRUE( q.empty() );
 117             ASSERT_CONTAINER_SIZE( q, 0 );
 118
 119             if ( std::is_same<typename Queue::disposer, cds::intrusive::opt::v::empty_disposer>::value ) {
 120                 // no disposer
 121                 for ( auto& i : arr ) {
 122                     ASSERT_EQ( i.nDisposeCount, 0 );
 123                 }
 124             }
 125             else {
 126                 // check the disposer has been called
 127                 for ( auto& i : arr ) {
 128                     ASSERT_EQ( i.nDisposeCount, 1 );
 129                 }
 130             }
 131
 132             // clear with disposer
 133             for ( auto& i : arr ) {
 134                 ASSERT_TRUE( q.push( i ) );
 135                 i.nDisposeCount = 0;
 136             }
 137             ASSERT_FALSE( q.empty() );
 138             ASSERT_CONTAINER_SIZE( q, q.capacity() );
 139             q.clear( []( value_type * p ) { p->nDisposeCount = p->nVal + 1; } );
 140             ASSERT_TRUE( q.empty() );
 141             ASSERT_CONTAINER_SIZE( q, 0 );
 142             // check the disposer has not been called
 143             for ( auto& i : arr ) {
 144                 ASSERT_EQ( i.nDisposeCount, i.nVal + 1 );
 145             }
 146         }
 147     };
 148
 149 } // namespace cds_test
 150
 151 #endif // CDSUNIT_QUEUE_TEST_INTRUSIVE_BOUNDED_QUEUE_H