projects / libcds.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
deleted tabs
[libcds.git] / test / unit / queue / fcqueue.cpp
diff --git a/test/unit/queue/fcqueue.cpp b/test/unit/queue/fcqueue.cpp
index 99f7b0c32b65a3c6c3e3048670ff51444989f22c..5b6040356ed271db7423247305522b2ef200355d 100644 (file)
--- a/test/unit/queue/fcqueue.cpp
+++ b/test/unit/queue/fcqueue.cpp
@@ -5,7 +5,7 @@
 
     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/container/fcqueue.h>
+#include <test/include/cds_test/fc_hevy_value.h>
 
 #include <list>
 
@@ -46,65 +47,65 @@ namespace {
 
             const size_t 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 );
             }
-            ASSERT_FALSE( q.empty() );
+            ASSERT_FALSE( q.empty());
             ASSERT_EQ( q.size(), nSize );
 
             for ( size_t i = 0; i < nSize; ++i ) {
                 it = -1;
                 ASSERT_TRUE( q.dequeue( it ));
-                ASSERT_EQ( it, i );
+                ASSERT_EQ( it, static_cast<value_type>( i ));
                 ASSERT_EQ( q.size(), 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 );
             }
-            ASSERT_FALSE( q.empty() );
+            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_TRUE( q.pop( it ));
+                ASSERT_EQ( it, static_cast<value_type>( i ));
                 ASSERT_EQ( q.size(), 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 )));
             }
-            ASSERT_FALSE( q.empty() );
+            ASSERT_FALSE( q.empty());
             ASSERT_EQ( q.size(), 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;
             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,8 +134,8 @@ 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 );
         }
     };
 
@@ -166,6 +167,67 @@ namespace {
         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( 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( 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( 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( 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( q );
+    }
+
     TEST_F( FCQueue, std_single_mutex_single_condvar )
     {
         typedef cds::container::FCQueue<int, std::queue< int, std::deque<int>>,
Unnamed repository; edit this file 'description' to name the repository.