test/unit/queue/test_generic_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_GENERIC_QUEUE_H
  32 #define CDSUNIT_QUEUE_TEST_GENERIC_QUEUE_H
  33
  34 #include <cds_test/check_size.h>
  35 \r
  36 namespace cds_test {\r
  37 \r
  38     class generic_queue : public ::testing::Test\r
  39     {\r
  40     protected:\r
  41         template <typename Queue>\r
  42         void test( Queue& q )\r
  43         {\r
  44             typedef typename Queue::value_type value_type;
  45             value_type it;
  46
  47             const size_t nSize = 100;
  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, 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, 0 );
 115
 116             // clear
 117             for ( size_t i = 0; i < nSize; ++i ) {
 118                 ASSERT_TRUE( q.push( static_cast<value_type>(i) ) );
 119             }
 120             ASSERT_FALSE( q.empty() );
 121             ASSERT_CONTAINER_SIZE( q, nSize );
 122
 123             q.clear();
 124             ASSERT_TRUE( q.empty() );
 125             ASSERT_CONTAINER_SIZE( q, 0 );
 126
 127             // pop from empty queue
 128             it = nSize * 2;
 129             ASSERT_FALSE( q.pop( it ) );
 130             ASSERT_EQ( it, nSize * 2 );
 131             ASSERT_TRUE( q.empty() );
 132             ASSERT_CONTAINER_SIZE( q, 0 );
 133
 134             ASSERT_FALSE( q.dequeue( it ) );
 135             ASSERT_EQ( it, nSize * 2 );
 136             ASSERT_TRUE( q.empty() );
 137             ASSERT_CONTAINER_SIZE( q, 0 );
 138         }\r
 139 \r
 140         template <class Queue>
 141         void test_string( Queue& q )
 142         {
 143             std::string str[3];
 144             str[0] = "one";
 145             str[1] = "two";
 146             str[2] = "three";
 147             const size_t nSize = sizeof( str ) / sizeof( str[0] );
 148
 149             // emplace
 150             for ( size_t i = 0; i < nSize; ++i ) {
 151                 ASSERT_TRUE( q.emplace( str[i].c_str()));
 152                 ASSERT_CONTAINER_SIZE( q, i + 1 );
 153             }
 154             ASSERT_FALSE( q.empty() );
 155             ASSERT_CONTAINER_SIZE( q, nSize );
 156
 157             {
 158                 std::string s;
 159                 auto f = [&s]( std::string& src ) {
 160                     ASSERT_FALSE( src.empty() );
 161                     s = std::move( src );
 162                     ASSERT_TRUE( src.empty() );
 163                 };
 164                 for ( size_t i = 0; i < nSize; ++i ) {
 165                     if ( i & 1 )
 166                         ASSERT_TRUE( q.pop_with( f ));
 167                     else
 168                         ASSERT_TRUE( q.dequeue_with( f ));
 169
 170                     ASSERT_CONTAINER_SIZE( q, nSize - i - 1 );
 171                     ASSERT_EQ( s, str[i] );
 172                 }
 173             }
 174             ASSERT_TRUE( q.empty() );
 175             ASSERT_CONTAINER_SIZE( q, 0 );
 176
 177
 178             // move push
 179             for ( size_t i = 0; i < nSize; ++i ) {
 180                 std::string s = str[i];
 181                 ASSERT_FALSE( s.empty() );
 182                 if ( i & 1 )
 183                     ASSERT_TRUE( q.enqueue( std::move( s )));
 184                 else
 185                     ASSERT_TRUE( q.push( std::move( s )));
 186                 ASSERT_TRUE( s.empty() );
 187                 ASSERT_CONTAINER_SIZE( q, i + 1 );
 188             }
 189             ASSERT_FALSE( q.empty() );
 190             ASSERT_CONTAINER_SIZE( q, nSize );
 191
 192             for ( size_t i = 0; i < nSize; ++i ) {
 193                 std::string s;
 194                 ASSERT_TRUE( q.pop( s ) );
 195                 ASSERT_CONTAINER_SIZE( q, nSize - i - 1 );
 196                 ASSERT_EQ( s, str[i] );
 197             }
 198             ASSERT_TRUE( q.empty() );
 199             ASSERT_CONTAINER_SIZE( q, 0 );
 200         }
 201 \r
 202     };\r
 203 \r
 204 } // namespace cds_test\r
 205 \r
 206 #endif // CDSUNIT_QUEUE_TEST_GENERIC_QUEUE_H\r