test/unit/queue/test_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_BOUNDED_QUEUE_H
  32 #define CDSUNIT_QUEUE_TEST_BOUNDED_QUEUE_H
  33
  34 #include <cds_test/check_size.h>
  35
  36 namespace cds_test {
  37
  38     class bounded_queue : public ::testing::Test
  39     {
  40     protected:
  41         template <typename Queue>
  42         void test( Queue& q )
  43         {
  44             typedef typename Queue::value_type value_type;
  45             value_type it;
  46
  47             const size_t nSize = q.capacity();
  48
  49             ASSERT_TRUE( q.empty() );
  50             ASSERT_CONTAINER_SIZE( q, 0 );
  51
  52             // enqueue/dequeue
  53             for ( size_t i = 0; i < nSize; ++i ) {
  54                 it = static_cast<value_type>(i);
  55                 ASSERT_TRUE( q.enqueue( it ));
  56                 ASSERT_CONTAINER_SIZE( q, i + 1 );
  57             }
  58             ASSERT_FALSE( q.empty() );
  59             ASSERT_CONTAINER_SIZE( q, nSize );
  60
  61             for ( size_t i = 0; i < nSize; ++i ) {
  62                 it = -1;
  63                 ASSERT_TRUE( q.dequeue( it ) );
  64                 ASSERT_EQ( it, static_cast<value_type>( i ));
  65                 ASSERT_CONTAINER_SIZE( q, nSize - i - 1 );
  66             }
  67             ASSERT_TRUE( q.empty() );
  68             ASSERT_CONTAINER_SIZE( q, 0 );
  69
  70             // push/pop
  71             for ( size_t i = 0; i < nSize; ++i ) {
  72                 it = static_cast<value_type>(i);
  73                 ASSERT_TRUE( q.push( it ));
  74                 ASSERT_CONTAINER_SIZE( q, i + 1 );
  75             }
  76             ASSERT_FALSE( q.empty() );
  77             ASSERT_CONTAINER_SIZE( q, nSize );
  78
  79             for ( size_t i = 0; i < nSize; ++i ) {
  80                 it = -1;
  81                 ASSERT_TRUE( q.pop( it ) );
  82                 ASSERT_EQ( it, i );
  83                 ASSERT_CONTAINER_SIZE( q, nSize - i - 1 );
  84             }
  85             ASSERT_TRUE( q.empty() );
  86             ASSERT_CONTAINER_SIZE( q, 0 );
  87
  88             // push/pop with lambda
  89             for ( size_t i = 0; i < nSize; ++i ) {
  90                 it = static_cast<value_type>(i);
  91                 ASSERT_NE( it, -1 );
  92                 auto f = [&it]( value_type& dest ) { dest = it; it = -1; };
  93                 if ( i & 1 )
  94                     ASSERT_TRUE( q.enqueue_with( f ));
  95                 else
  96                     ASSERT_TRUE( q.push_with( f ));
  97                 ASSERT_EQ( it, -1 );
  98                 ASSERT_CONTAINER_SIZE( q, i + 1 );
  99             }
 100             ASSERT_FALSE( q.empty() );
 101             ASSERT_CONTAINER_SIZE( q, nSize );
 102
 103             for ( size_t i = 0; i < nSize; ++i ) {
 104                 it = -1;
 105                 auto f = [&it]( value_type& src ) { it = src; src = -1; };
 106                 if ( i & 1 )
 107                     ASSERT_TRUE( q.pop_with( f ));
 108                 else
 109                     ASSERT_TRUE( q.dequeue_with( f ));
 110                 ASSERT_EQ( it, i );
 111                 ASSERT_CONTAINER_SIZE( q, nSize - i - 1 );
 112             }
 113             ASSERT_TRUE( q.empty() );
 114             ASSERT_CONTAINER_SIZE( q, 0u );
 115
 116             for ( size_t i = 0; i < nSize; ++i ) {
 117                 ASSERT_TRUE( q.push( static_cast<value_type>(i) ) );
 118             }
 119             ASSERT_FALSE( q.empty() );
 120             ASSERT_CONTAINER_SIZE( q, nSize );
 121
 122             // push in full queue
 123             ASSERT_FALSE( q.push( static_cast<int>(nSize * 2 )));
 124             ASSERT_FALSE( q.empty() );
 125             ASSERT_CONTAINER_SIZE( q, nSize );
 126             it = static_cast<int>( nSize * 2 );
 127             ASSERT_FALSE( q.enqueue( it ));
 128             ASSERT_FALSE( q.empty() );
 129             ASSERT_CONTAINER_SIZE( q, nSize );
 130
 131             // clear
 132             q.clear();
 133             ASSERT_TRUE( q.empty() );
 134             ASSERT_CONTAINER_SIZE( q, 0u );
 135
 136             // pop from empty queue
 137             it = static_cast<int>(nSize * 2);
 138             ASSERT_FALSE( q.pop( it ) );
 139             ASSERT_EQ( it, nSize * 2 );
 140             ASSERT_TRUE( q.empty() );
 141             ASSERT_CONTAINER_SIZE( q, 0u );
 142
 143             ASSERT_FALSE( q.dequeue( it ) );
 144             ASSERT_EQ( it, nSize * 2 );
 145             ASSERT_TRUE( q.empty() );
 146             ASSERT_CONTAINER_SIZE( q, 0u );
 147         }
 148
 149         template <class Queue>
 150         void test_string( Queue& q )
 151         {
 152             std::string str[3];
 153             str[0] = "one";
 154             str[1] = "two";
 155             str[2] = "three";
 156             const size_t nSize = sizeof( str ) / sizeof( str[0] );
 157
 158             // emplace
 159             for ( size_t i = 0; i < nSize; ++i ) {
 160                 ASSERT_TRUE( q.emplace( str[i].c_str()));
 161                 ASSERT_CONTAINER_SIZE( q, i + 1 );
 162             }
 163             ASSERT_FALSE( q.empty() );
 164             ASSERT_CONTAINER_SIZE( q, nSize );
 165
 166             {
 167                 std::string s;
 168                 auto f = [&s]( std::string& src ) {
 169                     ASSERT_FALSE( src.empty() );
 170                     s = std::move( src );
 171                     ASSERT_NE( s, src );
 172                 };
 173                 for ( size_t i = 0; i < nSize; ++i ) {
 174                     if ( i & 1 )
 175                         ASSERT_TRUE( q.pop_with( f ));
 176                     else
 177                         ASSERT_TRUE( q.dequeue_with( f ));
 178
 179                     ASSERT_CONTAINER_SIZE( q, nSize - i - 1 );
 180                     ASSERT_EQ( s, str[i] );
 181                 }
 182             }
 183             ASSERT_TRUE( q.empty() );
 184             ASSERT_CONTAINER_SIZE( q, 0 );
 185
 186
 187             // move push
 188             for ( size_t i = 0; i < nSize; ++i ) {
 189                 std::string s = str[i];
 190                 ASSERT_FALSE( s.empty());
 191                 if ( i & 1 )
 192                     ASSERT_TRUE( q.enqueue( std::move( s )));
 193                 else
 194                     ASSERT_TRUE( q.push( std::move( s )));
 195                 ASSERT_TRUE( s.empty() );
 196                 ASSERT_CONTAINER_SIZE( q, i + 1 );
 197             }
 198             ASSERT_FALSE( q.empty() );
 199             ASSERT_CONTAINER_SIZE( q, nSize );
 200
 201             for ( size_t i = 0; i < nSize; ++i ) {
 202                 std::string s;
 203                 ASSERT_TRUE( q.pop( s ) );
 204                 ASSERT_CONTAINER_SIZE( q, nSize - i - 1 );
 205                 ASSERT_EQ( s, str[i] );
 206             }
 207             ASSERT_TRUE( q.empty() );
 208             ASSERT_CONTAINER_SIZE( q, 0 );
 209         }
 210
 211     };
 212
 213 } // namespace cds_test
 214
 215 #endif // CDSUNIT_QUEUE_TEST_BOUNDED_QUEUE_H