projects / libcds.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Removed trailing spaces
[libcds.git] / test / unit / queue / fcqueue.cpp
diff --git a/test/unit/queue/fcqueue.cpp b/test/unit/queue/fcqueue.cpp
index 7681ddeb6946bd0c5531e999e32ba41160cdae4f..a757749241e085ed9bfa59087ac67b149a2a1c55 100644 (file)
--- a/test/unit/queue/fcqueue.cpp
+++ b/test/unit/queue/fcqueue.cpp
@@ -1,11 +1,11 @@
 /*
     This file is a part of libcds - Concurrent Data Structures library
 
-    (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
+    (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017
 
     Source code repo: http://github.com/khizmax/libcds/
     Download: http://sourceforge.net/projects/libcds/files/
-    
+
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:
 
@@ -25,11 +25,12 @@
     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#include <gtest/gtest.h>
+#include <cds_test/ext_gtest.h>
 #include <cds/container/fcqueue.h>
+#include <test/include/cds_test/fc_hevy_value.h>
 
 #include <list>
 
@@ -44,67 +45,67 @@ namespace {
             typedef typename Queue::value_type value_type;
             value_type it;
 
-            const size_t nSize = 100;
+            const int nSize = 100;
 
-            ASSERT_TRUE( q.empty() );
-            ASSERT_EQ( q.size(), 0 );
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
 
             // enqueue/dequeue
-            for ( size_t i = 0; i < nSize; ++i ) {
-                ASSERT_TRUE( q.enqueue( static_cast<value_type>(i)));
-                ASSERT_EQ( q.size(), i + 1 );
+            for ( int i = 0; i < nSize; ++i ) {
+                ASSERT_TRUE( q.enqueue( value_type(i)));
+                ASSERT_EQ( q.size(), static_cast<size_t>(i + 1));
             }
-            ASSERT_FALSE( q.empty() );
-            ASSERT_EQ( q.size(), nSize );
+            ASSERT_FALSE( q.empty());
+            ASSERT_EQ( q.size(), static_cast<size_t>( nSize ));
 
-            for ( size_t i = 0; i < nSize; ++i ) {
-                it = -1;
+            for ( int i = 0; i < nSize; ++i ) {
+                it = value_type( -1 );
                 ASSERT_TRUE( q.dequeue( it ));
-                ASSERT_EQ( it, i );
-                ASSERT_EQ( q.size(), nSize - i - 1 );
+                ASSERT_EQ( it, value_type( i ));
+                ASSERT_EQ( q.size(), static_cast<size_t>( nSize - i - 1 ));
             }
-            ASSERT_TRUE( q.empty() );
-            ASSERT_EQ( q.size(), 0 );
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
 
             // push/pop
-            for ( size_t i = 0; i < nSize; ++i ) {
-                ASSERT_TRUE( q.push( static_cast<value_type>(i)));
-                ASSERT_EQ( q.size(), i + 1 );
+            for ( int i = 0; i < nSize; ++i ) {
+                ASSERT_TRUE( q.push( value_type(i)));
+                ASSERT_EQ( q.size(), static_cast<size_t>( i + 1 ));
             }
-            ASSERT_FALSE( q.empty() );
-            ASSERT_EQ( q.size(), nSize );
-
-            for ( size_t i = 0; i < nSize; ++i ) {
-                it = -1;
-                ASSERT_TRUE( q.pop( it ) );
-                ASSERT_EQ( it, i );
-                ASSERT_EQ( q.size(), nSize - i - 1 );
+            ASSERT_FALSE( q.empty());
+            ASSERT_EQ( q.size(), static_cast<size_t>( nSize ));
+
+            for ( int i = 0; i < nSize; ++i ) {
+                it = value_type( -1 );
+                ASSERT_TRUE( q.pop( it ));
+                ASSERT_EQ( it, value_type( i ));
+                ASSERT_EQ( q.size(), static_cast<size_t>( nSize - i - 1 ));
             }
-            ASSERT_TRUE( q.empty() );
-            ASSERT_EQ( q.size(), 0 );
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
 
             // clear
-            for ( size_t i = 0; i < nSize; ++i ) {
-                ASSERT_TRUE( q.push( static_cast<value_type>( i )));
+            for ( int i = 0; i < nSize; ++i ) {
+                ASSERT_TRUE( q.push( value_type( i )));
             }
-            ASSERT_FALSE( q.empty() );
-            ASSERT_EQ( q.size(), nSize );
+            ASSERT_FALSE( q.empty());
+            ASSERT_EQ( q.size(), static_cast<size_t>( nSize ));
 
             q.clear();
-            ASSERT_TRUE( q.empty() );
-            ASSERT_EQ( q.size(), 0 );
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
 
             // pop from empty queue
-            it = nSize * 2;
+            it = value_type( nSize * 2 );
             ASSERT_FALSE( q.pop( it ));
-            ASSERT_EQ( it, nSize * 2 );
-            ASSERT_TRUE( q.empty() );
-            ASSERT_EQ( q.size(), 0 );
-
-            ASSERT_FALSE( q.dequeue( it ) );
-            ASSERT_EQ( it, nSize * 2 );
-            ASSERT_TRUE( q.empty() );
-            ASSERT_EQ( q.size(), 0 );
+            ASSERT_EQ( it, static_cast<value_type>( nSize * 2 ));
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
+
+            ASSERT_FALSE( q.dequeue( it ));
+            ASSERT_EQ( it, static_cast<value_type>( nSize * 2 ));
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
         }
 
         template <class Queue>
@@ -124,7 +125,7 @@ namespace {
                 ASSERT_FALSE( s.empty());
                 ASSERT_EQ( q.size(), i + 1 );
             }
-            ASSERT_FALSE( q.empty() );
+            ASSERT_FALSE( q.empty());
             ASSERT_EQ( q.size(), nSize );
 
             for ( size_t i = 0; i < nSize; ++i ) {
@@ -133,9 +134,79 @@ namespace {
                 ASSERT_EQ( q.size(), nSize - i - 1 );
                 ASSERT_EQ( s, str[i] );
             }
-            ASSERT_TRUE( q.empty() );
-            ASSERT_EQ( q.size(), 0 );
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
+        }
+
+        template <class Queue>
+        void test_heavy( Queue& q )
+        {
+            typedef typename Queue::value_type value_type;
+            value_type it;
+
+            const int nSize = 100;
+
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
+
+            // enqueue/dequeue
+            for ( int i = 0; i < nSize; ++i ) {
+                ASSERT_TRUE( q.enqueue( value_type( i )));
+                ASSERT_EQ( q.size(), static_cast<size_t>( i + 1 ));
+            }
+            ASSERT_FALSE( q.empty());
+            ASSERT_EQ( q.size(), static_cast<size_t>( nSize ));
+
+            for ( int i = 0; i < nSize; ++i ) {
+                it.value = -1;
+                ASSERT_TRUE( q.dequeue( it ));
+                ASSERT_EQ( it.value, i );
+                ASSERT_EQ( q.size(), static_cast<size_t>( nSize - i - 1 ));
+            }
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
+
+            // push/pop
+            for ( int i = 0; i < nSize; ++i ) {
+                ASSERT_TRUE( q.push( value_type( i )));
+                ASSERT_EQ( q.size(), static_cast<size_t>( i + 1 ));
+            }
+            ASSERT_FALSE( q.empty());
+            ASSERT_EQ( q.size(), static_cast<size_t>( nSize ));
+
+            for ( int i = 0; i < nSize; ++i ) {
+                it.value = -1;
+                ASSERT_TRUE( q.pop( it ));
+                ASSERT_EQ( it.value, i );
+                ASSERT_EQ( q.size(), static_cast<size_t>( nSize - i - 1 ));
+            }
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
+
+            // clear
+            for ( int i = 0; i < nSize; ++i ) {
+                ASSERT_TRUE( q.push( value_type( i )));
+            }
+            ASSERT_FALSE( q.empty());
+            ASSERT_EQ( q.size(), static_cast<size_t>( nSize ));
+
+            q.clear();
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
+
+            // pop from empty queue
+            it = value_type( nSize * 2 );
+            ASSERT_FALSE( q.pop( it ));
+            ASSERT_EQ( it.value, nSize * 2 );
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
+
+            ASSERT_FALSE( q.dequeue( it ));
+            ASSERT_EQ( it.value, nSize * 2 );
+            ASSERT_TRUE( q.empty());
+            ASSERT_EQ( q.size(), 0u );
         }
+
     };
 
     TEST_F( FCQueue, std_deque )
@@ -154,6 +225,91 @@ namespace {
         test_string( q );
     }
 
+    TEST_F( FCQueue, std_empty_wait_strategy )
+    {
+        typedef cds::container::FCQueue<int, std::queue< int, std::deque<int>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::empty >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
+    TEST_F( FCQueue, std_deque_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType> queue_type;
+
+        queue_type q;
+        test_heavy( q );
+    }
+
+    TEST_F( FCQueue, std_empty_wait_strategy_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType, std::queue< ValueType, std::deque<ValueType>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::empty >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test_heavy( q );
+    }
+
+    TEST_F( FCQueue, std_single_mutex_single_condvar_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType, std::queue< ValueType, std::deque<ValueType>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::single_mutex_single_condvar<> >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test_heavy( q );
+    }
+
+    TEST_F( FCQueue, std_single_mutex_multi_condvar_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType, std::queue< ValueType, std::deque<ValueType>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::single_mutex_multi_condvar<> >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test_heavy( q );
+    }
+
+    TEST_F( FCQueue, std_multi_mutex_multi_condvar_heavy_value )
+    {
+        typedef fc_test::heavy_value<> ValueType;
+        typedef cds::container::FCQueue<ValueType, std::queue< ValueType, std::deque<ValueType>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::multi_mutex_multi_condvar<> >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test_heavy( q );
+    }
+
+    TEST_F( FCQueue, std_single_mutex_single_condvar )
+    {
+        typedef cds::container::FCQueue<int, std::queue< int, std::deque<int>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::single_mutex_single_condvar<>>
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
     TEST_F( FCQueue, std_deque_elimination )
     {
         typedef cds::container::FCQueue<int, std::queue< int, std::deque<int>>,
@@ -166,6 +322,19 @@ namespace {
         test( q );
     }
 
+    TEST_F( FCQueue, std_deque_elimination_single_mutex_multi_condvar )
+    {
+        typedef cds::container::FCQueue<int, std::queue< int, std::deque<int>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::enable_elimination< true >
+                , cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::single_mutex_multi_condvar<2>>
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
     TEST_F( FCQueue, std_deque_elimination_move )
     {
         typedef cds::container::FCQueue<std::string, std::queue< std::string, std::deque<std::string>>,
@@ -178,6 +347,19 @@ namespace {
         test_string( q );
     }
 
+    TEST_F( FCQueue, std_deque_elimination_move_multi_mutex_multi_condvar )
+    {
+        typedef cds::container::FCQueue<std::string, std::queue< std::string, std::deque<std::string>>,
+            cds::container::fcqueue::make_traits<
+                cds::opt::enable_elimination< true >
+                , cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::multi_mutex_multi_condvar<>>
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test_string( q );
+    }
+
     TEST_F( FCQueue, std_deque_mutex )
     {
         typedef cds::container::FCQueue<int, std::queue< int, std::deque<int>>,
@@ -206,6 +388,30 @@ namespace {
         test_string( q );
     }
 
+    TEST_F( FCQueue, std_list_empty_wait_strategy )
+    {
+        typedef cds::container::FCQueue<int, std::queue< int, std::list<int> >,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::empty >
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
+    TEST_F( FCQueue, std_list_single_mutex_single_condvar )
+    {
+        typedef cds::container::FCQueue<int, std::queue< int, std::list<int> >,
+            cds::container::fcqueue::make_traits<
+                cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::single_mutex_single_condvar<5>>
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
     TEST_F( FCQueue, std_list_elimination )
     {
         typedef cds::container::FCQueue<int, std::queue< int, std::list<int> >,
@@ -218,6 +424,19 @@ namespace {
         test( q );
     }
 
+    TEST_F( FCQueue, std_list_elimination_multi_mutex_multi_condvar )
+    {
+        typedef cds::container::FCQueue<int, std::queue< int, std::list<int> >,
+            cds::container::fcqueue::make_traits<
+                cds::opt::enable_elimination< true >
+                ,cds::opt::wait_strategy< cds::algo::flat_combining::wait_strategy::multi_mutex_multi_condvar<5>>
+            >::type
+        > queue_type;
+
+        queue_type q;
+        test( q );
+    }
+
     TEST_F( FCQueue, std_list_elimination_move )
     {
         typedef cds::container::FCQueue<std::string, std::queue< std::string, std::list<std::string> >,
Unnamed repository; edit this file 'description' to name the repository.