Fixed -Wshadow warnings

[libcds.git] / test / unit / pqueue / intrusive_mspqueue.cpp

diff --git a/test/unit/pqueue/intrusive_mspqueue.cpp b/test/unit/pqueue/intrusive_mspqueue.cpp
index 1c019943bd49a5984146a59d65c95666fbf01f49..5fa1921afc0c225ecae6dd47101621df083c3d50 100644 (file)
--- a/test/unit/pqueue/intrusive_mspqueue.cpp
+++ b/test/unit/pqueue/intrusive_mspqueue.cpp
@@ -1,7 +1,7 @@
 /*
     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/
@@ -54,47 +54,47 @@ namespace {
         template <class PQueue>
         void test( PQueue& pq )
         {
-            data_array<value_type> arr( pq.capacity() );
+            data_array<value_type> arr( pq.capacity());
             value_type * pFirst = arr.begin();
             value_type * pLast = arr.end();
 
-            ASSERT_TRUE( pq.empty() );
-            ASSERT_FALSE( pq.full() );
-            ASSERT_EQ( pq.size(), 0 );
-            ASSERT_EQ( pq.capacity(), base_class::c_nCapacity - 1 );
+            ASSERT_TRUE( pq.empty());
+            ASSERT_FALSE( pq.full());
+            ASSERT_EQ( pq.size(), 0u );
+            ASSERT_EQ( pq.capacity(), static_cast<size_t>( base_class::c_nCapacity - 1 ));
 
             size_t nSize = 0;
 
             // Push test
             for ( value_type * p = pFirst; p < pLast; ++p ) {
-                ASSERT_TRUE( pq.push( *p ) );
-                ASSERT_FALSE( pq.empty() );
+                ASSERT_TRUE( pq.push( *p ));
+                ASSERT_FALSE( pq.empty());
                 ASSERT_EQ( pq.size(), ++nSize );
             }
 
-            ASSERT_TRUE( pq.full() );
-            ASSERT_EQ( pq.size(), pq.capacity() );
+            ASSERT_TRUE( pq.full());
+            ASSERT_EQ( pq.size(), pq.capacity());
 
             // The queue is full
             {
                 value_type k( base_class::c_nMinValue + key_type( base_class::c_nCapacity ));
-                ASSERT_FALSE( pq.push( k ) );
-                ASSERT_TRUE( pq.full() );
-                ASSERT_EQ( pq.size(), pq.capacity() );
+                ASSERT_FALSE( pq.push( k ));
+                ASSERT_TRUE( pq.full());
+                ASSERT_EQ( pq.size(), pq.capacity());
             }
 
             // Pop test
-            key_type nPrev = base_class::c_nMinValue + key_type( pq.capacity() ) - 1;
+            key_type nPrev = base_class::c_nMinValue + key_type( pq.capacity()) - 1;
             value_type * p = pq.pop();
             ASSERT_TRUE( p != nullptr );
             EXPECT_EQ( p->k, nPrev );
 
             ASSERT_EQ( pq.size(), pq.capacity() - 1 );
-            ASSERT_FALSE( pq.full() );
-            ASSERT_FALSE( pq.empty() );
+            ASSERT_FALSE( pq.full());
+            ASSERT_FALSE( pq.empty());
 
             nSize = pq.size();
-            while ( pq.size() > 1 ) {
+            while ( pq.size() > 1u ) {
                 p = pq.pop();
                 ASSERT_TRUE( p != nullptr );
                 EXPECT_EQ( p->k, nPrev - 1 );
@@ -103,51 +103,51 @@ namespace {
                 ASSERT_EQ( pq.size(), nSize );
             }
 
-            ASSERT_FALSE( pq.full() );
-            ASSERT_FALSE( pq.empty() );
-            ASSERT_EQ( pq.size(), 1 );
+            ASSERT_FALSE( pq.full());
+            ASSERT_FALSE( pq.empty());
+            ASSERT_EQ( pq.size(), 1u );
 
             p = pq.pop();
             ASSERT_TRUE( p != nullptr );
             EXPECT_EQ( p->k, base_class::c_nMinValue );
 
-            ASSERT_FALSE( pq.full() );
-            ASSERT_TRUE( pq.empty() );
-            ASSERT_EQ( pq.size(), 0 );
+            ASSERT_FALSE( pq.full());
+            ASSERT_TRUE( pq.empty());
+            ASSERT_EQ( pq.size(), 0u );
 
             // Clear test
-            for ( value_type * p = pFirst; p < pLast; ++p ) {
-                ASSERT_TRUE( pq.push( *p ) );
+            for ( p = pFirst; p < pLast; ++p ) {
+                ASSERT_TRUE( pq.push( *p ));
             }
-            EXPECT_FALSE( pq.empty() );
-            EXPECT_TRUE( pq.full() );
-            EXPECT_EQ( pq.size(), pq.capacity() );
+            EXPECT_FALSE( pq.empty());
+            EXPECT_TRUE( pq.full());
+            EXPECT_EQ( pq.size(), pq.capacity());
             pq.clear();
-            EXPECT_TRUE( pq.empty() );
-            EXPECT_FALSE( pq.full() );
-            EXPECT_EQ( pq.size(), 0 );
+            EXPECT_TRUE( pq.empty());
+            EXPECT_FALSE( pq.full());
+            EXPECT_EQ( pq.size(), 0u );
 
             // clear_with test
-            for ( value_type * p = pFirst; p < pLast; ++p ) {
-                ASSERT_TRUE( pq.push( *p ) );
+            for ( p = pFirst; p < pLast; ++p ) {
+                ASSERT_TRUE( pq.push( *p ));
             }
-            ASSERT_FALSE( pq.empty() );
-            ASSERT_TRUE( pq.full() );
-            ASSERT_EQ( pq.size(), pq.capacity() );
+            ASSERT_FALSE( pq.empty());
+            ASSERT_TRUE( pq.full());
+            ASSERT_EQ( pq.size(), pq.capacity());
 
             {
                 disposer disp;
-                pq.clear_with( std::ref( disp ) );
-                ASSERT_TRUE( pq.empty() );
-                ASSERT_FALSE( pq.full() );
-                ASSERT_EQ( pq.size(), 0 );
-                ASSERT_EQ( disp.m_nCallCount, pq.capacity() );
+                pq.clear_with( std::ref( disp ));
+                ASSERT_TRUE( pq.empty());
+                ASSERT_FALSE( pq.full());
+                ASSERT_EQ( pq.size(), 0u );
+                ASSERT_EQ( disp.m_nCallCount, pq.capacity());
             }
         }
     };
 
-    typedef cds::opt::v::dynamic_buffer< char > dyn_buffer_type;
-    typedef cds::opt::v::static_buffer< char, IntrusiveMSPQueue::c_nCapacity > static_buffer_type;
+    typedef cds::opt::v::initialized_dynamic_buffer< char > dyn_buffer_type;
+    typedef cds::opt::v::initialized_static_buffer< char, IntrusiveMSPQueue::c_nCapacity > static_buffer_type;
 
     TEST_F( IntrusiveMSPQueue, dynamic )
     {
@@ -236,7 +236,7 @@ namespace {
             >::type
         > pqueue;
 
-        std::unique_ptr<pqueue> pq( new pqueue( 0 ) );
+        std::unique_ptr<pqueue> pq( new pqueue( 0 ));
         test( *pq );
     }
 
@@ -249,7 +249,7 @@ namespace {
             >::type
         > pqueue;
 
-        std::unique_ptr<pqueue> pq( new pqueue( 0 ) );
+        std::unique_ptr<pqueue> pq( new pqueue( 0 ));
         test( *pq );
     }
 
@@ -263,7 +263,7 @@ namespace {
         };
         typedef cds::intrusive::MSPriorityQueue< value_type, traits > pqueue;
 
-        std::unique_ptr<pqueue> pq( new pqueue( 0 ) );
+        std::unique_ptr<pqueue> pq( new pqueue( 0 ));
         test( *pq );
     }