Fixed -Wshadow warnings

diff --git a/cds/container/impl/bronson_avltree_map_rcu.h b/cds/container/impl/bronson_avltree_map_rcu.h
index f21253b5728529262d7bf252b7290dc1d3a53f49..a855ff24b00d851d57ef5b9ff38ded62dd060aa4 100644 (file)
--- a/cds/container/impl/bronson_avltree_map_rcu.h
+++ b/cds/container/impl/bronson_avltree_map_rcu.h
@@ -381,9 +381,9 @@ namespace cds { namespace container {
             return do_remove(
                 key,
                 key_comparator(),
-                [&f]( key_type const& key, mapped_type pVal, rcu_disposer& disp ) -> bool {
+                [&f]( key_type const& k, mapped_type pVal, rcu_disposer& disp ) -> bool {
                     assert( pVal );
-                    f( key, *pVal );
+                    f( k, *pVal );
                     disp.dispose_value(pVal);
                     return true;
                 }
@@ -404,9 +404,9 @@ namespace cds { namespace container {
             return do_remove(
                 key,
                 cds::opt::details::make_comparator_from_less<Less>(),
-                [&f]( key_type const& key, mapped_type pVal, rcu_disposer& disp ) -> bool {
+                [&f]( key_type const& k, mapped_type pVal, rcu_disposer& disp ) -> bool {
                     assert( pVal );
-                    f( key, *pVal );
+                    f( k, *pVal );
                     disp.dispose_value(pVal);
                     return true;
                 }
@@ -1410,10 +1410,10 @@ namespace cds { namespace container {
         {
             node_type * pNew;
 
-            auto fnCreateNode = [&funcUpdate]( node_type * pNew ) {
-                mapped_type pVal = funcUpdate( pNew );
+            auto fnCreateNode = [&funcUpdate]( node_type * pNode ) {
+                mapped_type pVal = funcUpdate( pNode );
                 assert( pVal != nullptr );
-                pNew->m_pValue.store( pVal, memory_model::memory_order_release );
+                pNode->m_pValue.store( pVal, memory_model::memory_order_release );
             };
 
             static_if ( c_bRelaxedInsert ) {

diff --git a/cds/container/impl/lazy_list.h b/cds/container/impl/lazy_list.h
index 7d91b0ee6d6ab3997285e9928da1b539f4a7ee16..96c37b814fac248c5fcc15f818c659a6c7627ac2 100644 (file)
--- a/cds/container/impl/lazy_list.h
+++ b/cds/container/impl/lazy_list.h
@@ -851,7 +851,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool find_at( head_type& refHead, Q& val, Compare cmp, Func f )
         {
-            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& val){ f( node_to_value(node), val ); });
+            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& v){ f( node_to_value(node), v ); });
         }
 
         template <typename Q, typename Compare>

diff --git a/cds/container/impl/skip_list_set.h b/cds/container/impl/skip_list_set.h
index ab075e9702448206e2d2264b320852ec485df84b..7901f7d0a8f9f02714ab7751a423ce422cb9b384 100644 (file)
--- a/cds/container/impl/skip_list_set.h
+++ b/cds/container/impl/skip_list_set.h
@@ -313,7 +313,7 @@ namespace cds { namespace container {
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr sp( node_allocator().New( random_level(), val ));
-            if ( base_class::insert( *sp.get(), [&f]( node_type& val ) { f( val.m_Value ); } )) {
+            if ( base_class::insert( *sp.get(), [&f]( node_type& v ) { f( v.m_Value ); } )) {
                 sp.release();
                 return true;
             }

diff --git a/cds/container/lazy_list_rcu.h b/cds/container/lazy_list_rcu.h
index 738e50426c36e3e5dfe68ed2284027dbe809532f..60c724e01fd537aa40fe7b126a684814f674f93e 100644 (file)
--- a/cds/container/lazy_list_rcu.h
+++ b/cds/container/lazy_list_rcu.h
@@ -821,13 +821,13 @@ namespace cds { namespace container {
         template <typename Q, typename Compare>
         bool find_at( head_type& refHead, Q const& key, Compare cmp ) const
         {
-            return base_class::find_at( &refHead, key, cmp, [](node_type&, Q const &) {} );
+            return base_class::find_at( &refHead, key, cmp, [](node_type&, Q const&) {} );
         }
 
         template <typename Q, typename Compare, typename Func>
         bool find_at( head_type& refHead, Q& val, Compare cmp, Func f ) const
         {
-            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& val){ f( node_to_value(node), val ); });
+            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& v){ f( node_to_value(node), v ); });
         }
 
         template <typename Q, typename Compare>

diff --git a/cds/container/michael_map.h b/cds/container/michael_map.h
index 912ae81daef79af486deffdeb9ed5e4f59cff2a8..9947409d7643e722d8e72eb3e362c15b0ec4507c 100644 (file)
--- a/cds/container/michael_map.h
+++ b/cds/container/michael_map.h
@@ -990,15 +990,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
         //@endcond
     };

diff --git a/cds/container/michael_map_nogc.h b/cds/container/michael_map_nogc.h
index 04299da93a61e64ab3255ab5322b2653f74c18a5..610eef33901a96f15683d7c8f86f2db061c543fa 100644 (file)
--- a/cds/container/michael_map_nogc.h
+++ b/cds/container/michael_map_nogc.h
@@ -590,15 +590,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
         //@endcond
     };

diff --git a/cds/container/michael_map_rcu.h b/cds/container/michael_map_rcu.h
index 93198b8d33c82855b8abb3156e81e350065121f9..ef44254733453213a4c5a74108c6117fb595e5b8 100644 (file)
--- a/cds/container/michael_map_rcu.h
+++ b/cds/container/michael_map_rcu.h
@@ -855,15 +855,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bkt )
         {
-            new (bucket) internal_bucket_type;
+            new (bkt) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bkt )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (bkt) internal_bucket_type( m_Stat );
         }
         //@endcond
     };

diff --git a/cds/container/michael_set.h b/cds/container/michael_set.h
index 32fddca4b131de57f1a8fe3e4c2ee170da1205f8..85ffc5378ee42b8d34311d6307c0873b78910641 100644 (file)
--- a/cds/container/michael_set.h
+++ b/cds/container/michael_set.h
@@ -943,15 +943,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
 
         template <typename List, typename... Args>

diff --git a/cds/container/michael_set_nogc.h b/cds/container/michael_set_nogc.h
index efb6901b38174d9bf9cdf453969013b95cbb2e40..5874dd206700a4987162c8f3db6b75514ed31fb5 100644 (file)
--- a/cds/container/michael_set_nogc.h
+++ b/cds/container/michael_set_nogc.h
@@ -430,15 +430,15 @@ namespace cds { namespace container {
     private:
         //@cond
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
 
         const_iterator get_const_begin() const

diff --git a/cds/container/michael_set_rcu.h b/cds/container/michael_set_rcu.h
index 34bc0c2bbf33058f4153cdcbffc8a2cb5d6ee947..54cf0686157ac4b592fd99e2d419f9bf0e9165e4 100644 (file)
--- a/cds/container/michael_set_rcu.h
+++ b/cds/container/michael_set_rcu.h
@@ -797,15 +797,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bkt )
         {
-            new (bucket) internal_bucket_type;
+            new (bkt) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bkt )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (bkt) internal_bucket_type( m_Stat );
         }
 
         const_iterator get_const_begin() const

diff --git a/cds/container/skip_list_set_rcu.h b/cds/container/skip_list_set_rcu.h
index daf05f2b0c99bc89f60e13dbcbb33ac152f75e86..b34ccba1965d47b8daa747c731a58c0f4afd71cb 100644 (file)
--- a/cds/container/skip_list_set_rcu.h
+++ b/cds/container/skip_list_set_rcu.h
@@ -358,7 +358,7 @@ namespace cds { namespace container {
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr sp( node_allocator().New( random_level(), val ));
-            if ( base_class::insert( *sp.get(), [&f]( node_type& val ) { f( val.m_Value ); } )) {
+            if ( base_class::insert( *sp.get(), [&f]( node_type& v ) { f( v.m_Value ); } )) {
                 sp.release();
                 return true;
             }

diff --git a/cds/container/split_list_set.h b/cds/container/split_list_set.h
index b4af551d6919f30dc21cc911e08abb03441f48e9..47d48865ea46408e8960f8e389d7e81768950ada 100644 (file)
--- a/cds/container/split_list_set.h
+++ b/cds/container/split_list_set.h
@@ -936,7 +936,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find_( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& item, Q& val ) { f( item.m_Value, val ); } );
+            return base_class::find( val, [&f]( node_type& item, Q& v ) { f( item.m_Value, v ); } );
         }
 
         template <typename Q>
@@ -951,7 +951,7 @@ namespace cds { namespace container {
         {
             CDS_UNUSED( pred );
             return base_class::find_with( val, typename maker::template predicate_wrapper<Less>::type(),
-                [&f]( node_type& item, Q& val ) { f( item.m_Value, val ); } );
+                [&f]( node_type& item, Q& v ) { f( item.m_Value, v ); } );
         }
 
         template <typename Q, typename Less>

diff --git a/cds/container/split_list_set_rcu.h b/cds/container/split_list_set_rcu.h
index 36f45517af518213bddd5719232d0d0bd245a7d8..c72295a1f703a1ba8c6d689db124b5affaf3d08b 100644 (file)
--- a/cds/container/split_list_set_rcu.h
+++ b/cds/container/split_list_set_rcu.h
@@ -315,7 +315,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find_( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
+            return base_class::find( val, [&f]( node_type& item, Q& v ) { f(item.m_Value, v) ; } );
         }
 
         template <typename Q, typename Less, typename Func>
@@ -323,7 +323,7 @@ namespace cds { namespace container {
         {
             CDS_UNUSED( pred );
             return base_class::find_with( val, typename maker::template predicate_wrapper<Less>::type(),
-                [&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
+                [&f]( node_type& item, Q& v ) { f(item.m_Value, v) ; } );
         }
 
         template <typename Q>

diff --git a/cds/intrusive/free_list_cached.h b/cds/intrusive/free_list_cached.h
index 9c9adea2497c12548cb83f9b595aacc825904cc0..3fd3b090dcfcd32c2cb4ec21e29c16b73fffbdf2 100644 (file)
--- a/cds/intrusive/free_list_cached.h
+++ b/cds/intrusive/free_list_cached.h
@@ -121,9 +121,9 @@ namespace cds { namespace intrusive {
                 return p;
 
             // iterate the cache
-            for ( auto& cell : m_cache ) {
-                p = cell.load( atomics::memory_order_relaxed );
-                if ( p && cell.compare_exchange_weak( p, nullptr, atomics::memory_order_acquire, atomics::memory_order_relaxed ))
+            for ( auto& item : m_cache ) {
+                p = item.load( atomics::memory_order_relaxed );
+                if ( p && item.compare_exchange_weak( p, nullptr, atomics::memory_order_acquire, atomics::memory_order_relaxed ))
                     return p;
             }
 

diff --git a/cds/intrusive/impl/ellen_bintree.h b/cds/intrusive/impl/ellen_bintree.h
index 974854b48fac1972b17a30597e8318b30439b532..3ab0923be12cbb26d1a6e345cc5f5624ffe45542 100644 (file)
--- a/cds/intrusive/impl/ellen_bintree.h
+++ b/cds/intrusive/impl/ellen_bintree.h
@@ -918,18 +918,18 @@ namespace cds { namespace intrusive {
         retry:
             tree_node * p = bRight
                 ? res.guards.protect( search_result::Guard_Leaf, pParent->m_pRight,
-                    []( tree_node * p ) -> internal_node* { return static_cast<internal_node *>(p);})
+                    []( tree_node * pn ) -> internal_node* { return static_cast<internal_node *>(pn);})
                 : res.guards.protect( search_result::Guard_Leaf, pParent->m_pLeft,
-                    []( tree_node * p ) -> internal_node* { return static_cast<internal_node *>(p);});
+                    []( tree_node * pn ) -> internal_node* { return static_cast<internal_node *>(pn);});
 
             // If we use member hook, data node pointer != internal node pointer
             // So, we need protect the child twice: as internal node and as data node
             // and then analyze what kind of node we have
             tree_node * pVal = bRight
                 ? res.guards.protect( search_result::Guard_temporary, pParent->m_pRight,
-                    []( tree_node * p ) -> value_type* { return node_traits::to_value_ptr( static_cast<leaf_node *>(p));} )
+                    []( tree_node * pn ) -> value_type* { return node_traits::to_value_ptr( static_cast<leaf_node *>(pn));} )
                 : res.guards.protect( search_result::Guard_temporary, pParent->m_pLeft,
-                    []( tree_node * p ) -> value_type* { return node_traits::to_value_ptr( static_cast<leaf_node *>(p));} );
+                    []( tree_node * pn ) -> value_type* { return node_traits::to_value_ptr( static_cast<leaf_node *>(pn));} );
 
             // child node is guarded
             // See whether pParent->m_pUpdate has not been changed

diff --git a/cds/intrusive/lazy_list_nogc.h b/cds/intrusive/lazy_list_nogc.h
index 01fc656e4528ce6a6827a844e32a8d1f95fa086d..2c9761f54fb209b02a807badb233f6366b0fef74 100644 (file)
--- a/cds/intrusive/lazy_list_nogc.h
+++ b/cds/intrusive/lazy_list_nogc.h
@@ -480,10 +480,10 @@ namespace cds { namespace intrusive {
             \p Equal functor has the interface like \p std::equal_to.
         */
         template <typename Q, typename Equal, typename Func, bool Sort = c_bSort>
-        typename std::enable_if<!Sort, bool>::type find_with( Q& key, Equal equal, Func f )
+        typename std::enable_if<!Sort, bool>::type find_with( Q& key, Equal eq, Func f )
         {
-            CDS_UNUSED( equal );
-            return find_at( &m_Head, key, equal, f );
+            //CDS_UNUSED( eq );
+            return find_at( &m_Head, key, eq, f );
         }
         //@cond
         template <typename Q, typename Less, typename Func, bool Sort = c_bSort>
@@ -494,10 +494,10 @@ namespace cds { namespace intrusive {
         }
 
         template <typename Q, typename Equal, typename Func, bool Sort = c_bSort>
-        typename std::enable_if<!Sort, bool>::type find_with( Q const& key, Equal equal, Func f )
+        typename std::enable_if<!Sort, bool>::type find_with( Q const& key, Equal eq, Func f )
         {
-            CDS_UNUSED( equal );
-            return find_at( &m_Head, key, equal, f );
+            //CDS_UNUSED( eq );
+            return find_at( &m_Head, key, eq, f );
         }
         //@endcond
 
@@ -547,16 +547,16 @@ namespace cds { namespace intrusive {
             \p Equal functor has the interface like \p std::equal_to.
         */
         template <typename Q, typename Equal, bool Sort = c_bSort>
-        typename std::enable_if<!Sort, value_type *>::type contains( Q const& key, Equal equal )
+        typename std::enable_if<!Sort, value_type *>::type contains( Q const& key, Equal eq )
         {
-            return find_at( &m_Head, key, equal );
+            return find_at( &m_Head, key, eq );
         }
         //@cond
         template <typename Q, typename Equal, bool Sort = c_bSort>
         CDS_DEPRECATED("deprecated, use contains()")
-        typename std::enable_if<!Sort, value_type *>::type find_with( Q const& key, Equal equal )
+        typename std::enable_if<!Sort, value_type *>::type find_with( Q const& key, Equal eq )
         {
-            return contains( key, equal );
+            return contains( key, eq );
         }
         //@endcond
 

diff --git a/cds/intrusive/michael_set.h b/cds/intrusive/michael_set.h
index fe2c2f95666bbf2f0f7df95c3b11da74ea7016a2..79b2b8cbf7264f41ea6be1c0df33698c5b95a39a 100644 (file)
--- a/cds/intrusive/michael_set.h
+++ b/cds/intrusive/michael_set.h
@@ -982,15 +982,15 @@ namespace cds { namespace intrusive {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
 
         /// Calculates hash value of \p key

diff --git a/cds/intrusive/michael_set_nogc.h b/cds/intrusive/michael_set_nogc.h
index 883e8526bfe048ab3e5aec63d725a62128b737ff..dfe01d1e052f7776dbb5f5c88269d4f85df67700 100644 (file)
--- a/cds/intrusive/michael_set_nogc.h
+++ b/cds/intrusive/michael_set_nogc.h
@@ -455,15 +455,15 @@ namespace cds { namespace intrusive {
     private:
         //@cond
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
         //@endcond
     };

diff --git a/cds/intrusive/michael_set_rcu.h b/cds/intrusive/michael_set_rcu.h
index 43a26138460ddeacce0b46efe27487bcda7ccc9f..2a0d9bd4eae353d796dcb041bbe95bd5dd42c97e 100644 (file)
--- a/cds/intrusive/michael_set_rcu.h
+++ b/cds/intrusive/michael_set_rcu.h
@@ -735,15 +735,15 @@ namespace cds { namespace intrusive {
     private:
         //@cond
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * bkt )
         {
-            new (bucket) internal_bucket_type;
+            new (bkt) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * bkt )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (bkt) internal_bucket_type( m_Stat );
         }
 
         /// Calculates hash value of \p key

diff --git a/cds/intrusive/msqueue.h b/cds/intrusive/msqueue.h
index 98d8a64e82f6f91574d65bb37d5af06d055956fa..0313390559b6f524aa60874e939227b133ab7ea7 100644 (file)
--- a/cds/intrusive/msqueue.h
+++ b/cds/intrusive/msqueue.h
@@ -584,7 +584,7 @@ namespace cds { namespace intrusive {
         bool empty() const
         {
             typename gc::Guard guard;
-            node_type * p = guard.protect( m_pHead, []( node_type * p ) -> value_type * { return node_traits::to_value_ptr( p );});
+            node_type * p = guard.protect( m_pHead, []( node_type * pNode ) -> value_type * { return node_traits::to_value_ptr( pNode );});
             return p->m_pNext.load( memory_model::memory_order_relaxed ) == nullptr;
         }
 

diff --git a/cds/intrusive/split_list.h b/cds/intrusive/split_list.h
index 691a089d4d059d64bd21b1214c533355c0dfedf7..7ef5bfdef5ffc3e566d18d53f8e127b554307c2c 100644 (file)
--- a/cds/intrusive/split_list.h
+++ b/cds/intrusive/split_list.h
@@ -1325,7 +1325,7 @@ namespace cds { namespace intrusive {
 
             return m_Stat.onFind(
                 m_List.find_at( pHead, sv, cmp,
-                    [&f]( value_type& item, split_list::details::search_value_type<Q>& val ) { f( item, val.val ); } )
+                    [&f]( value_type& item, split_list::details::search_value_type<Q>& v ) { f( item, v.val ); } )
             );
         }
 

diff --git a/cds/intrusive/split_list_nogc.h b/cds/intrusive/split_list_nogc.h
index 68c0d250fb294b7187a8cc42b7422f9e7130f5e1..966f5da3aea33bf038ab936ccaaa5431ea18da3f 100644 (file)
--- a/cds/intrusive/split_list_nogc.h
+++ b/cds/intrusive/split_list_nogc.h
@@ -582,7 +582,7 @@ namespace cds { namespace intrusive {
             aux_node_type * pHead = get_bucket( nHash );
             assert( pHead != nullptr );
             return m_Stat.onFind( m_List.find_at( pHead, sv, cmp,
-                [&f](value_type& item, split_list::details::search_value_type<Q>& val){ f(item, val.val ); }));
+                [&f](value_type& item, split_list::details::search_value_type<Q>& v){ f(item, v.val ); }));
         }
 
         aux_node_type * alloc_aux_node( size_t nHash )

diff --git a/cds/intrusive/split_list_rcu.h b/cds/intrusive/split_list_rcu.h
index 64583fe402133f1bcb6f9f4299156ec4cc992ed7..48c49a28becb75cc8e6243d7b71971a93ebe99f0 100644 (file)
--- a/cds/intrusive/split_list_rcu.h
+++ b/cds/intrusive/split_list_rcu.h
@@ -1019,7 +1019,7 @@ namespace cds { namespace intrusive {
             assert( pHead != nullptr );
 
             return m_Stat.onFind( m_List.find_at( pHead, sv, cmp,
-                [&f](value_type& item, split_list::details::search_value_type<Q>& val){ f(item, val.val ); }));
+                [&f](value_type& item, split_list::details::search_value_type<Q>& v){ f(item, v.val ); }));
         }
 
         template <typename Q, typename Compare>

diff --git a/test/include/cds_test/thread.h b/test/include/cds_test/thread.h
index 44baffdb6a96a6d17f0178bc287ea7d6c662d484..51fc399a200ca3157a06be83d2a96cbb681c60a4 100644 (file)
--- a/test/include/cds_test/thread.h
+++ b/test/include/cds_test/thread.h
@@ -156,8 +156,8 @@ namespace cds_test {
         };
 
     public:
-        explicit thread_pool( ::testing::Test& fixture )
-            : m_fixture( fixture )
+        explicit thread_pool( ::testing::Test& fx )
+            : m_fixture( fx )
             , m_bTimeElapsed( false )
         {}
 

diff --git a/test/stress/framework/city.cpp b/test/stress/framework/city.cpp
index 1d995578ff43f6064a05f3ee479592af421df9b4..321cea1b017da509279ce9aff1e652ea201cc537 100644 (file)
--- a/test/stress/framework/city.cpp
+++ b/test/stress/framework/city.cpp
@@ -200,11 +200,11 @@ uint32 CityHash32(const char *s, size_t len) {
   f = f * 5 + 0xe6546b64;
   size_t iters = (len - 1) / 20;
   do {
-    uint32 a0 = Rotate32(Fetch32(s) * c1, 17) * c2;
-    uint32 a1 = Fetch32(s + 4);
-    uint32 a2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
-    uint32 a3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
-    uint32 a4 = Fetch32(s + 16);
+    a0 = Rotate32(Fetch32(s) * c1, 17) * c2;
+    a1 = Fetch32(s + 4);
+    a2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
+    a3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
+    a4 = Fetch32(s + 16);
     h ^= a0;
     h = Rotate32(h, 18);
     h = h * 5 + 0xe6546b64;

diff --git a/test/unit/intrusive-list/test_intrusive_list_nogc.h b/test/unit/intrusive-list/test_intrusive_list_nogc.h
index 08274cc6ac9066e640dd25cbca03e31c9747162b..c023d00076c185b2ef230f7490187dedd18ca0b4 100644 (file)
--- a/test/unit/intrusive-list/test_intrusive_list_nogc.h
+++ b/test/unit/intrusive-list/test_intrusive_list_nogc.h
@@ -329,11 +329,11 @@ namespace cds_test {
                 EXPECT_FALSE( ret.second );
                 EXPECT_EQ( i.s.nUpdateExistsCall, 1 );
 
-                ret = l.update( i, []( bool bNew, value_type& i, value_type& arg ) {
+                ret = l.update( i, []( bool bNew, value_type& vi, value_type& arg ) {
                     EXPECT_FALSE( bNew );
-                    EXPECT_EQ( i.s.nUpdateExistsCall, 1 );
-                    EXPECT_TRUE( &i == &arg );
-                    ++i.s.nUpdateExistsCall;
+                    EXPECT_EQ( vi.s.nUpdateExistsCall, 1 );
+                    EXPECT_TRUE( &vi == &arg );
+                    ++vi.s.nUpdateExistsCall;
                 });
                 EXPECT_TRUE( ret.first );
                 EXPECT_FALSE( ret.second );

diff --git a/test/unit/intrusive-set/test_intrusive_michael_lazy_rcu.h b/test/unit/intrusive-set/test_intrusive_michael_lazy_rcu.h
index d8312680b00b4f1cc260cbf40f56da9be3cc90eb..5c036504ba11fbc8d11cb0c79587fb48fe3e3a02 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_michael_lazy_rcu.h
+++ b/test/unit/intrusive-set/test_intrusive_michael_lazy_rcu.h
@@ -68,14 +68,14 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
         , base_item_type
         , typename ci::lazy_list::make_traits<
             ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type > > >
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -95,14 +95,14 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, base_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<base_item_type> less;
+    typedef typename TestFixture::template less<base_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
         , base_item_type
         , typename ci::lazy_list::make_traits<
             ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type >>>
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -232,7 +232,7 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
@@ -242,7 +242,7 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, member_cmp )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             >>
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     >    bucket_type;
@@ -262,7 +262,7 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, member_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<member_item_type> less;
+    typedef typename TestFixture::template less<member_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
@@ -272,7 +272,7 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, member_less )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             > >
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;

diff --git a/test/unit/intrusive-set/test_intrusive_michael_michael_rcu.h b/test/unit/intrusive-set/test_intrusive_michael_michael_rcu.h
index 1c3873171fa3246be1c0059d08cc929a466e09ef..5d9e3ee70a659347020e1b29f22bfda8e9069233 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_michael_michael_rcu.h
+++ b/test/unit/intrusive-set/test_intrusive_michael_michael_rcu.h
@@ -66,14 +66,14 @@ TYPED_TEST_P( IntrusiveMichaelSet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
         , base_item_type
         , typename ci::michael_list::make_traits<
             ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type > > >
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -93,14 +93,14 @@ TYPED_TEST_P( IntrusiveMichaelSet, base_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<base_item_type> less;
+    typedef typename TestFixture::template less<base_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
         , base_item_type
         , typename ci::michael_list::make_traits<
             ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type >>>
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -205,7 +205,7 @@ TYPED_TEST_P( IntrusiveMichaelSet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
@@ -215,7 +215,7 @@ TYPED_TEST_P( IntrusiveMichaelSet, member_cmp )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             >>
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     >    bucket_type;
@@ -235,7 +235,7 @@ TYPED_TEST_P( IntrusiveMichaelSet, member_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<member_item_type> less;
+    typedef typename TestFixture::template less<member_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
@@ -245,7 +245,7 @@ TYPED_TEST_P( IntrusiveMichaelSet, member_less )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             > >
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;

diff --git a/test/unit/intrusive-set/test_intrusive_skiplist_rcu.h b/test/unit/intrusive-set/test_intrusive_skiplist_rcu.h
index ee62fc2735e2c66617b8f41a016e8256490e993f..63347a8b8743d4f607a0f60ee36548d04c3d9874 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_skiplist_rcu.h
+++ b/test/unit/intrusive-set/test_intrusive_skiplist_rcu.h
@@ -65,13 +65,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
     };
 
     typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type;
@@ -106,14 +106,14 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_cmpmix )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::template less<base_item_type> less_predicate;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
     };
@@ -129,13 +129,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_xorshift32 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::xorshift32 random_level_generator;
     };
 
@@ -150,13 +150,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_xorshift24 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::xorshift24 random_level_generator;
     };
 
@@ -171,13 +171,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_xorshift16 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::xorshift16 random_level_generator;
     };
 
@@ -192,13 +192,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_turbo32 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::turbo32 random_level_generator;
     };
 
@@ -234,13 +234,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_turbo16 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::turbo16 random_level_generator;
     };
 
@@ -256,13 +256,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
     };
 
     typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type;
@@ -300,13 +300,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_cmpmix )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
     };
@@ -323,13 +323,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_xorshift32 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::xorshift32 random_level_generator;
@@ -347,13 +347,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_xorshift24 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::xorshift24 random_level_generator;
@@ -371,13 +371,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_xorshift16 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::xorshift16 random_level_generator;
@@ -395,13 +395,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_turbo32 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::turbo32 random_level_generator;
@@ -419,13 +419,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_turbo24 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::turbo24 random_level_generator;
@@ -443,13 +443,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_turbo16 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::turbo16 random_level_generator;

diff --git a/test/unit/intrusive-set/test_intrusive_split_lazy_rcu.h b/test/unit/intrusive-set/test_intrusive_split_lazy_rcu.h
index 7d7176aaba13044f745682898a63333fe4fffc3f..73e5416273557b3ddd1fa42195bcc0c83dad08c9 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_split_lazy_rcu.h
+++ b/test/unit/intrusive-set/test_intrusive_split_lazy_rcu.h
@@ -69,14 +69,14 @@ TYPED_TEST_P( IntrusiveSplitLazySet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
         , base_item_type
         , typename ci::lazy_list::make_traits<
             ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type > > >
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -96,14 +96,14 @@ TYPED_TEST_P( IntrusiveSplitLazySet, base_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<base_item_type> less;
+    typedef typename TestFixture::template less<base_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
         , base_item_type
         , typename ci::lazy_list::make_traits<
             ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type >>>
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -270,7 +270,7 @@ TYPED_TEST_P( IntrusiveSplitLazySet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
@@ -280,7 +280,7 @@ TYPED_TEST_P( IntrusiveSplitLazySet, member_cmp )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             >>
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     >    bucket_type;
@@ -300,7 +300,7 @@ TYPED_TEST_P( IntrusiveSplitLazySet, member_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<member_item_type> less;
+    typedef typename TestFixture::template less<member_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
@@ -310,7 +310,7 @@ TYPED_TEST_P( IntrusiveSplitLazySet, member_less )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             > >
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;

diff --git a/test/unit/intrusive-set/test_intrusive_split_michael_rcu.h b/test/unit/intrusive-set/test_intrusive_split_michael_rcu.h
index cb7b48268726811d60dc7b3bc8a14053cc5230f3..5f1cf5b54a3bab3f3236623aa746dd4813c556db 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_split_michael_rcu.h
+++ b/test/unit/intrusive-set/test_intrusive_split_michael_rcu.h
@@ -67,14 +67,14 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
         , base_item_type
         , typename ci::michael_list::make_traits<
             ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type > > >
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -94,14 +94,14 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, base_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<base_item_type> less;
+    typedef typename TestFixture::template less<base_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
         , base_item_type
         , typename ci::michael_list::make_traits<
             ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type >>>
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -324,7 +324,7 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
@@ -334,7 +334,7 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, member_cmp )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             >>
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     >    bucket_type;
@@ -354,7 +354,7 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, member_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<member_item_type> less;
+    typedef typename TestFixture::template less<member_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
@@ -364,7 +364,7 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, member_less )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             > >
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;

diff --git a/test/unit/misc/cxx11_atomic_class.cpp b/test/unit/misc/cxx11_atomic_class.cpp
index c17702ad3238e0b9be59e3fe2265a7b4eb94c3bb..4041d8f70a0ae595b9625610871119049dca0d3b 100644 (file)
--- a/test/unit/misc/cxx11_atomic_class.cpp
+++ b/test/unit/misc/cxx11_atomic_class.cpp
@@ -526,14 +526,14 @@ namespace {
             EXPECT_EQ( *a.load( oLoad ), 1 );
 
             for ( integral_type i = 1; i < aSize; ++i ) {
-                integral_type * p = a.load();
+                p = a.load();
                 EXPECT_EQ( *p, i );
                 EXPECT_EQ( a.fetch_add( 1, order ), p );
                 EXPECT_EQ( *a.load( oLoad ), i + 1 );
             }
 
             for ( integral_type i = aSize; i > 1; --i ) {
-                integral_type * p = a.load();
+                p = a.load();
                 EXPECT_EQ( *p, i  );
                 EXPECT_EQ( a.fetch_sub( 1, order ), p );
                 EXPECT_EQ( *a.load( oLoad ), i - 1 );
@@ -578,7 +578,7 @@ namespace {
             EXPECT_EQ( *a.load(), 1 );
 
             for ( integral_type i = 1; i < aSize; ++i ) {
-                integral_type * p = a.load();
+                p = a.load();
                 EXPECT_EQ( *p, i );
                 integral_type * pa = a.fetch_add( 1 );
                 EXPECT_EQ( pa, p );
@@ -586,7 +586,7 @@ namespace {
             }
 
             for ( integral_type i = aSize; i > 1; --i ) {
-                integral_type * p = a.load();
+                p = a.load();
                 EXPECT_EQ( *p, i  );
                 EXPECT_EQ( a.fetch_sub( 1 ), p );
                 EXPECT_EQ( *a.load(), i - 1 );

diff --git a/test/unit/misc/cxx11_atomic_func.cpp b/test/unit/misc/cxx11_atomic_func.cpp
index 432ed4e546d625807c3cffe45852485408acb34e..20c948f0b2332b0ab9361bc8b7f5f2bd8d341c52 100644 (file)
--- a/test/unit/misc/cxx11_atomic_func.cpp
+++ b/test/unit/misc/cxx11_atomic_func.cpp
@@ -416,14 +416,14 @@ namespace misc {
             EXPECT_EQ( *atomics::atomic_load_explicit( &a, oLoad ), 1 );
 
             for ( integral_type i = 1; i < aSize; ++i ) {
-                integral_type * p = atomics::atomic_load_explicit( &a, oLoad );
+                p = atomics::atomic_load_explicit( &a, oLoad );
                 EXPECT_EQ( *p, i );
                 EXPECT_EQ( atomics::atomic_fetch_add_explicit( &a, 1, order ), p );
                 EXPECT_EQ( *atomics::atomic_load_explicit( &a, oLoad ), i + 1 );
             }
 
             for ( integral_type i = aSize; i > 1; --i ) {
-                integral_type * p = atomics::atomic_load_explicit( &a, oLoad );
+                p = atomics::atomic_load_explicit( &a, oLoad );
                 EXPECT_EQ( *p, i  );
                 EXPECT_EQ( atomics::atomic_fetch_sub_explicit( &a, 1, order ), p );
                 EXPECT_EQ( *atomics::atomic_load_explicit( &a, oLoad ), i - 1 );
@@ -464,14 +464,14 @@ namespace misc {
             EXPECT_EQ( *atomics::atomic_load( &a ), 1 );
 
             for ( integral_type i = 1; i < aSize; ++i ) {
-                integral_type * p = atomics::atomic_load( &a );
+                p = atomics::atomic_load( &a );
                 EXPECT_EQ( *p, i );
                 EXPECT_EQ( atomics::atomic_fetch_add( &a, 1 ), p );
                 EXPECT_EQ( *atomics::atomic_load( &a ), i + 1 );
             }
 
             for ( integral_type i = aSize; i > 1; --i ) {
-                integral_type * p = atomics::atomic_load( &a );
+                p = atomics::atomic_load( &a );
                 EXPECT_EQ( *p, i );
                 EXPECT_EQ( atomics::atomic_fetch_sub( &a, 1 ), p );
                 EXPECT_EQ( *atomics::atomic_load( &a ), i - 1 );

diff --git a/test/unit/pqueue/intrusive_mspqueue.cpp b/test/unit/pqueue/intrusive_mspqueue.cpp
index b91c1a69fa30c5c4fbfffbcf79375c651a0af465..5fa1921afc0c225ecae6dd47101621df083c3d50 100644 (file)
--- a/test/unit/pqueue/intrusive_mspqueue.cpp
+++ b/test/unit/pqueue/intrusive_mspqueue.cpp
@@ -116,7 +116,7 @@ namespace {
             ASSERT_EQ( pq.size(), 0u );
 
             // Clear test
-            for ( value_type * p = pFirst; p < pLast; ++p ) {
+            for ( p = pFirst; p < pLast; ++p ) {
                 ASSERT_TRUE( pq.push( *p ));
             }
             EXPECT_FALSE( pq.empty());
@@ -128,7 +128,7 @@ namespace {
             EXPECT_EQ( pq.size(), 0u );
 
             // clear_with test
-            for ( value_type * p = pFirst; p < pLast; ++p ) {
+            for ( p = pFirst; p < pLast; ++p ) {
                 ASSERT_TRUE( pq.push( *p ));
             }
             ASSERT_FALSE( pq.empty());

diff --git a/test/unit/striped-set/test_striped_set.h b/test/unit/striped-set/test_striped_set.h
index 1e7dec47b99cd8b40ae178d9c3058188361c6bba..338ebcdc76937f7eade5d6b4250d97cdbfa2f0dc 100644 (file)
--- a/test/unit/striped-set/test_striped_set.h
+++ b/test/unit/striped-set/test_striped_set.h
@@ -72,8 +72,8 @@ namespace {
         template <typename Func>
         bool operator()( Set& s, int key, Func f ) const
         {
-            return s.find( key, [&f]( typename Set::value_type& v, int key ) {
-                cds_test::container_set::other_item oi( key );
+            return s.find( key, [&f]( typename Set::value_type& v, int k ) {
+                cds_test::container_set::other_item oi( k );
                 f( v, oi );
             });
         }

diff --git a/test/unit/tree/test_bronson_avltree_map.h b/test/unit/tree/test_bronson_avltree_map.h
index d82c9d1170e9e3b8ae85b191e9e4ff856a7f13b7..9145c71880c712965282c3bb9af0384d1f007d25 100644 (file)
--- a/test/unit/tree/test_bronson_avltree_map.h
+++ b/test/unit/tree/test_bronson_avltree_map.h
@@ -93,25 +93,25 @@ namespace {
                 case 0:
                     ASSERT_TRUE( m.insert( i ));
                     ASSERT_FALSE( m.insert( i ));
-                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     break;
                 case 1:
                     ASSERT_TRUE( m.insert( i.nKey ));
                     ASSERT_FALSE( m.insert( i.nKey ));
-                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     break;
                 case 2:
                     ASSERT_TRUE( m.insert( std::to_string( i.nKey )));
                     ASSERT_FALSE( m.insert( std::to_string( i.nKey )));
-                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     break;
                 case 3:
@@ -127,27 +127,27 @@ namespace {
                     ASSERT_FALSE( m.insert( val.strVal, i.nKey ));
                     break;
                 case 6:
-                    ASSERT_TRUE( m.insert_with( i, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.insert_with( i, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     ASSERT_FALSE( m.insert_with( i, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     } ));
                     break;
                 case 7:
-                    ASSERT_TRUE( m.insert_with( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.insert_with( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     ASSERT_FALSE( m.insert_with( i.nKey, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     } ));
                     break;
                 case 8:
-                    ASSERT_TRUE( m.insert_with( val.strVal, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.insert_with( val.strVal, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     ASSERT_FALSE( m.insert_with( val.strVal, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
@@ -160,17 +160,17 @@ namespace {
                     ASSERT_FALSE( updResult.first );
                     ASSERT_FALSE( updResult.second );
 
-                    updResult = m.update( i.nKey, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( i.nKey, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_TRUE( bNew );
-                        val.nVal = key.nKey;
+                        v.nVal = key.nKey;
                     });
                     ASSERT_TRUE( updResult.first );
                     ASSERT_TRUE( updResult.second );
 
-                    updResult = m.update( i.nKey, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( i.nKey, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_FALSE( bNew );
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        val.strVal = std::to_string( val.nVal );
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        v.strVal = std::to_string( v.nVal );
                     } );
                     ASSERT_TRUE( updResult.first );
                     ASSERT_FALSE( updResult.second );
@@ -182,17 +182,17 @@ namespace {
                     ASSERT_FALSE( updResult.first );
                     ASSERT_FALSE( updResult.second );
 
-                    updResult = m.update( i, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( i, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_TRUE( bNew );
-                        val.nVal = key.nKey;
+                        v.nVal = key.nKey;
                     });
                     ASSERT_TRUE( updResult.first );
                     ASSERT_TRUE( updResult.second );
 
-                    updResult = m.update( i, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( i, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_FALSE( bNew );
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        val.strVal = std::to_string( val.nVal );
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        v.strVal = std::to_string( v.nVal );
                     } );
                     ASSERT_TRUE( updResult.first );
                     ASSERT_FALSE( updResult.second );
@@ -204,17 +204,17 @@ namespace {
                     ASSERT_FALSE( updResult.first );
                     ASSERT_FALSE( updResult.second );
 
-                    updResult = m.update( val.strVal, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( val.strVal, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_TRUE( bNew );
-                        val.nVal = key.nKey;
+                        v.nVal = key.nKey;
                     });
                     ASSERT_TRUE( updResult.first );
                     ASSERT_TRUE( updResult.second );
 
-                    updResult = m.update( val.strVal, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( val.strVal, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_FALSE( bNew );
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        val.strVal = std::to_string( val.nVal );
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        v.strVal = std::to_string( v.nVal );
                     } );
                     ASSERT_TRUE( updResult.first );
                     ASSERT_FALSE( updResult.second );
@@ -222,9 +222,9 @@ namespace {
                 case 12:
                     ASSERT_TRUE( m.emplace( i.nKey ));
                     ASSERT_FALSE( m.emplace( i.nKey ));
-                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     break;
                 case 13:
@@ -256,17 +256,17 @@ namespace {
                 ASSERT_TRUE( m.contains( i.nKey ));
                 ASSERT_TRUE( m.contains( i ));
                 ASSERT_TRUE( m.contains( other_item( i.nKey ), other_less()));
-                ASSERT_TRUE( m.find( i, []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find( i, []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
-                ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
-                ASSERT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
             }
             ASSERT_FALSE( m.empty());
@@ -284,17 +284,17 @@ namespace {
                 ASSERT_TRUE( m.contains( val.strVal ));
                 ASSERT_TRUE( m.contains( i ));
                 ASSERT_TRUE( m.contains( other_item( i.nKey ), other_less()));
-                ASSERT_TRUE( m.find( i, []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find( i, []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
-                ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
-                ASSERT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
 
 
@@ -316,36 +316,36 @@ namespace {
                     ASSERT_FALSE( m.erase_with( other_item( i.nKey ), other_less()));
                     break;
                 case 4:
-                    ASSERT_TRUE( m.erase( i, []( key_type const& key, value_type& val ) {
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                    ASSERT_TRUE( m.erase( i, []( key_type const& key, value_type& v ) {
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                     }));
                     ASSERT_FALSE( m.erase( i, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 5:
-                    ASSERT_TRUE( m.erase( i.nKey, []( key_type const& key, value_type& val ) {
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                    ASSERT_TRUE( m.erase( i.nKey, []( key_type const& key, value_type& v ) {
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                     }));
                     ASSERT_FALSE( m.erase( i.nKey, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 6:
-                    ASSERT_TRUE( m.erase( val.strVal, []( key_type const& key, value_type& val ) {
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                    ASSERT_TRUE( m.erase( val.strVal, []( key_type const& key, value_type& v ) {
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                     }));
                     ASSERT_FALSE( m.erase( val.strVal, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 7:
-                    ASSERT_TRUE( m.erase_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& val ) {
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                    ASSERT_TRUE( m.erase_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& v ) {
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                     }));
                     ASSERT_FALSE( m.erase_with( other_item( i.nKey ), other_less(), []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );