Removed redundant spaces

diff --git a/cds/container/details/make_lazy_kvlist.h b/cds/container/details/make_lazy_kvlist.h
index dbe53f2a613ec5db54b1b8d9ce3b6e900b70e6bf..bc7d109f9d275bf749d0f44397aefa0ca281bec2 100644 (file)
--- a/cds/container/details/make_lazy_kvlist.h
+++ b/cds/container/details/make_lazy_kvlist.h
@@ -87,7 +87,7 @@ namespace cds { namespace container {
 
                 template <typename Ky, typename... Args>
                 node_type( Ky&& key, Args&&... args )
-                    : m_Data( key_type( std::forward<Ky>( key )), std::move( mapped_type( std::forward<Args>( args )... )) )
+                    : m_Data( key_type( std::forward<Ky>( key )), std::move( mapped_type( std::forward<Args>( args )... )))
                 {}
             };
 

diff --git a/cds/container/lazy_kvlist_nogc.h b/cds/container/lazy_kvlist_nogc.h
index e123b8d89616d1e36a7a8eccab179be54e23ee82..6e2b2fcb26adaf8340d051afd3cf602c29447fcf 100644 (file)
--- a/cds/container/lazy_kvlist_nogc.h
+++ b/cds/container/lazy_kvlist_nogc.h
@@ -475,7 +475,7 @@ namespace cds { namespace container {
         template <typename Q>
         iterator contains( Q const& key )
         {
-            return node_to_iterator( find_at( head(), key, intrusive_key_comparator()) );
+            return node_to_iterator( find_at( head(), key, intrusive_key_comparator()));
         }
         //@cond
         template <typename Q>
@@ -496,7 +496,7 @@ namespace cds { namespace container {
         typename std::enable_if<Sort, iterator>::type contains( Q const& key, Less pred )
         {
             CDS_UNUSED( pred );
-            return node_to_iterator( find_at( head(), key, typename maker::template less_wrapper<Less>::type()) );
+            return node_to_iterator( find_at( head(), key, typename maker::template less_wrapper<Less>::type()));
         }
         //@cond
         template <typename Q, typename Less, bool Sort = c_bSort>
@@ -516,7 +516,7 @@ namespace cds { namespace container {
         typename std::enable_if<!Sort, iterator>::type contains( Q const& key, Equal equal )
         {
             CDS_UNUSED( equal );
-            return node_to_iterator( find_at( head(), key, typename maker::template equal_to_wrapper<Equal>::type()) );
+            return node_to_iterator( find_at( head(), key, typename maker::template equal_to_wrapper<Equal>::type()));
         }
         //@cond
         template <typename Q, typename Equal, bool Sort = c_bSort>

diff --git a/cds/container/michael_kvlist_nogc.h b/cds/container/michael_kvlist_nogc.h
index 43c3e1f14dc070725499e2eeea9f38a85c3dd2e8..e43c87c11d251fc15ae1390c26b620567a2f6176 100644 (file)
--- a/cds/container/michael_kvlist_nogc.h
+++ b/cds/container/michael_kvlist_nogc.h
@@ -446,7 +446,7 @@ namespace cds { namespace container {
         template <typename Q>
         iterator contains( Q const& key )
         {
-            return node_to_iterator( find_at( head(), key, intrusive_key_comparator()) );
+            return node_to_iterator( find_at( head(), key, intrusive_key_comparator()));
         }
         //@cond
         template <typename Q>
@@ -467,7 +467,7 @@ namespace cds { namespace container {
         iterator contains( Q const& key, Less pred )
         {
             CDS_UNUSED( pred );
-            return node_to_iterator( find_at( head(), key, typename maker::template less_wrapper<Less>::type()) );
+            return node_to_iterator( find_at( head(), key, typename maker::template less_wrapper<Less>::type()));
         }
         //@cond
         template <typename Q, typename Less>

diff --git a/cds/container/michael_list_nogc.h b/cds/container/michael_list_nogc.h
index 277560b24256cc453708a195f67b683cc2f0ac3d..a3b881b2aa232445eda94ad0a52e685f7e57f797 100644 (file)
--- a/cds/container/michael_list_nogc.h
+++ b/cds/container/michael_list_nogc.h
@@ -369,7 +369,7 @@ namespace cds { namespace container {
         iterator contains( Q const& key, Less pred )
         {
             CDS_UNUSED( pred );
-            return node_to_iterator( find_at( head(), key, typename maker::template less_wrapper<Less>::type()) );
+            return node_to_iterator( find_at( head(), key, typename maker::template less_wrapper<Less>::type()));
         }
         //@cond
         template <typename Q, typename Less>

diff --git a/cds/container/michael_map.h b/cds/container/michael_map.h
index 71287e4dd58cdeda8bfb3c592e22fc6c4d73d9b0..7ba149e23615dc01e98ff7e62624ae5d70302e2d 100644 (file)
--- a/cds/container/michael_map.h
+++ b/cds/container/michael_map.h
@@ -402,7 +402,7 @@ namespace cds { namespace container {
             size_t nLoadFactor      ///< load factor: estimation of max number of items in the bucket
             )
             : m_nHashBitmask( michael_map::details::init_hash_bitmask( nMaxItemCount, nLoadFactor ))
-            , m_Buckets( bucket_table_allocator().allocate( bucket_count()) )
+            , m_Buckets( bucket_table_allocator().allocate( bucket_count()))
         {
             for ( auto it = m_Buckets, itEnd = m_Buckets + bucket_count(); it != itEnd; ++it )
                 construct_bucket<bucket_stat>( it );

diff --git a/cds/container/michael_set.h b/cds/container/michael_set.h
index 81823a23791e4f6d80c026b658a98ba93d874290..e2aa8c3a73779dacc128059f640c0b2afe15c814 100644 (file)
--- a/cds/container/michael_set.h
+++ b/cds/container/michael_set.h
@@ -332,7 +332,7 @@ namespace cds { namespace container {
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set
             size_t nLoadFactor      ///< load factor: estimation of max number of items in the bucket
         ) : m_nHashBitmask( michael_set::details::init_hash_bitmask( nMaxItemCount, nLoadFactor ))
-          , m_Buckets( bucket_table_allocator().allocate( bucket_count()) )
+          , m_Buckets( bucket_table_allocator().allocate( bucket_count()))
         {
             for ( auto it = m_Buckets, itEnd = m_Buckets + bucket_count(); it != itEnd; ++it )
                 construct_bucket<bucket_stat>( it );

diff --git a/cds/container/michael_set_nogc.h b/cds/container/michael_set_nogc.h
index a921ff4349a3f0e356d0fc70d7eaec1682b016fe..9854ac07fd71c4590b60c7eb499859b3d20df322 100644 (file)
--- a/cds/container/michael_set_nogc.h
+++ b/cds/container/michael_set_nogc.h
@@ -225,7 +225,7 @@ namespace cds { namespace container {
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set
             size_t nLoadFactor      ///< load factor: estimation of max number of items in the bucket
         ) : m_nHashBitmask( michael_set::details::init_hash_bitmask( nMaxItemCount, nLoadFactor ))
-          , m_Buckets( bucket_table_allocator().allocate( bucket_count()) )
+          , m_Buckets( bucket_table_allocator().allocate( bucket_count()))
         {
             for ( auto it = m_Buckets, itEnd = m_Buckets + bucket_count(); it != itEnd; ++it )
                 construct_bucket<bucket_stat>( it );

diff --git a/cds/container/michael_set_rcu.h b/cds/container/michael_set_rcu.h
index 9733f4c9fa8bf5c00f029b34620cb7a70c46fc7d..d2e47bcc1763b18db2365fb3874908acde06a58b 100644 (file)
--- a/cds/container/michael_set_rcu.h
+++ b/cds/container/michael_set_rcu.h
@@ -302,7 +302,7 @@ namespace cds { namespace container {
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set
             size_t nLoadFactor      ///< load factor: estimation of max number of items in the bucket
         ) : m_nHashBitmask( michael_set::details::init_hash_bitmask( nMaxItemCount, nLoadFactor ))
-          , m_Buckets( bucket_table_allocator().allocate( bucket_count()) )
+          , m_Buckets( bucket_table_allocator().allocate( bucket_count()))
         {
             for ( auto it = m_Buckets, itEnd = m_Buckets + bucket_count(); it != itEnd; ++it )
                 construct_bucket<bucket_stat>( it );

diff --git a/cds/container/rwqueue.h b/cds/container/rwqueue.h
index 028a08b7042293a8473d6ab5fc4e284fc1b00f32..ffd6adfff3d615c8ec18392353a7492f1d06e3f8 100644 (file)
--- a/cds/container/rwqueue.h
+++ b/cds/container/rwqueue.h
@@ -256,7 +256,7 @@ namespace cds { namespace container {
         bool enqueue( value_type&& data )
         {
             scoped_node_ptr p( alloc_node_move( std::move( data )));
-            if ( enqueue_node( p.get()) ) {
+            if ( enqueue_node( p.get())) {
                 p.release();
                 return true;
             }

diff --git a/cds/container/skip_list_map_nogc.h b/cds/container/skip_list_map_nogc.h
index 388cf46b4748b8f661b67af68fdf239b7fbdabe3..0740bef1f548011b23c29b8908908fe9dc5d968f 100644 (file)
--- a/cds/container/skip_list_map_nogc.h
+++ b/cds/container/skip_list_map_nogc.h
@@ -196,7 +196,7 @@ namespace cds { namespace container {
         iterator insert( K const& key )
         {
             //TODO: pass arguments by reference (make_pair makes copy)
-            return base_class::insert( std::make_pair( key_type( key ), mapped_type()) );
+            return base_class::insert( std::make_pair( key_type( key ), mapped_type()));
         }
 
         /// Inserts new node

diff --git a/cds/container/striped_map.h b/cds/container/striped_map.h
index 46ecd8959ad67b26e096dd24b79af31f7bed28f0..17e6462e0410313ca0e9f7873a2993468760e8ae 100644 (file)
--- a/cds/container/striped_map.h
+++ b/cds/container/striped_map.h
@@ -378,7 +378,7 @@ namespace cds { namespace container {
                             {
                                 std::swap(
                                     map.insert(
-                                        std::map::value_type( itWhat->first, T()) ).first->second
+                                        std::map::value_type( itWhat->first, T())).first->second
                                         , itWhat->second
                                 ));
                             }

diff --git a/cds/container/striped_map/std_hash_map.h b/cds/container/striped_map/std_hash_map.h
index 3f07addcae734bd5fc2b7f7090485a7b96179b98..884083cdc9bc30f2fc2120b0d2c0f252ec7b4417 100644 (file)
--- a/cds/container/striped_map/std_hash_map.h
+++ b/cds/container/striped_map/std_hash_map.h
@@ -149,7 +149,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             std::pair<bool, bool> update( const Q& key, Func func, bool bAllowInsert )
             {
                 if ( bAllowInsert ) {
-                    std::pair<iterator, bool> res = m_Map.insert( value_type( key_type( key ), mapped_type()) );
+                    std::pair<iterator, bool> res = m_Map.insert( value_type( key_type( key ), mapped_type()));
                     func( res.second, const_cast<value_type&>(*res.first));
                     return std::make_pair( true, res.second );
                 }

diff --git a/cds/container/striped_map/std_map.h b/cds/container/striped_map/std_map.h
index 9eeca8c015dc97a43fe02b896ff55e7d796bfff0..f42e788c338c6f70c54f80a20638879ce7f690a1 100644 (file)
--- a/cds/container/striped_map/std_map.h
+++ b/cds/container/striped_map/std_map.h
@@ -132,7 +132,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             template <typename Q, typename Func>
             bool insert( const Q& key, Func f )
             {
-                std::pair<iterator, bool> res = m_Map.insert( value_type( key_type( key ), mapped_type()) );
+                std::pair<iterator, bool> res = m_Map.insert( value_type( key_type( key ), mapped_type()));
                 if ( res.second )
                     f( *res.first );
                 return res.second;

diff --git a/cds/container/striped_set/adapter.h b/cds/container/striped_set/adapter.h
index 26faff5b75214dd8891399dea76c610bf8a5fcb9..03a5cb48cf35bfa5dda43bff6bacdad89fa3d874 100644 (file)
--- a/cds/container/striped_set/adapter.h
+++ b/cds/container/striped_set/adapter.h
@@ -452,7 +452,7 @@ namespace cds { namespace container {
                 template <typename Q, typename Func>
                 bool insert( const Q& key, Func f )
                 {
-                    std::pair<iterator, bool> res = m_Map.insert( value_type( key_type( key ), mapped_type()) );
+                    std::pair<iterator, bool> res = m_Map.insert( value_type( key_type( key ), mapped_type()));
                     if ( res.second )
                         f( *res.first );
                     return res.second;

diff --git a/cds/gc/details/dhp.h b/cds/gc/details/dhp.h
index 927476575c04f635ebd056df05d100b8ad34fc89..5f03cc8f675b3c7188b20df068da1032522a773b 100644 (file)
--- a/cds/gc/details/dhp.h
+++ b/cds/gc/details/dhp.h
@@ -670,7 +670,7 @@ namespace cds { namespace gc {
             template <typename T>
             void retirePtr( T * p, void (* pFunc)(T *))
             {
-                retirePtr( retired_ptr( reinterpret_cast<void *>( p ), reinterpret_cast<free_retired_ptr_func>( pFunc )) );
+                retirePtr( retired_ptr( reinterpret_cast<void *>( p ), reinterpret_cast<free_retired_ptr_func>( pFunc )));
             }
 
             /// Places retired pointer \p into thread's array of retired pointer for deferred reclamation

diff --git a/cds/intrusive/impl/ellen_bintree.h b/cds/intrusive/impl/ellen_bintree.h
index 0321fbb962932df83fbafeaf86d89e9dbe0cc540..27c513fad2051369fc8827615b3d912affbbada6 100644 (file)
--- a/cds/intrusive/impl/ellen_bintree.h
+++ b/cds/intrusive/impl/ellen_bintree.h
@@ -851,7 +851,7 @@ namespace cds { namespace intrusive {
                 assert( pLeaf->is_leaf());
 
                 pGrandParent->m_pLeft.store( pParent->m_pRight.load( memory_model::memory_order_relaxed ), memory_model::memory_order_relaxed );
-                free_leaf_node( node_traits::to_value_ptr( static_cast<leaf_node *>( pLeaf )) );
+                free_leaf_node( node_traits::to_value_ptr( static_cast<leaf_node *>( pLeaf )));
                 free_internal_node( pParent );
             }
         }
@@ -1555,7 +1555,7 @@ namespace cds { namespace intrusive {
         guarded_ptr get_( Q const& val ) const
         {
             search_result    res;
-            if ( search( res, val, node_compare()) ) {
+            if ( search( res, val, node_compare())) {
                 assert( res.pLeaf );
                 m_Stat.onFindSuccess();
                 return guarded_ptr( res.guards.release( search_result::Guard_Leaf ));
@@ -1578,7 +1578,7 @@ namespace cds { namespace intrusive {
             > compare_functor;
 
             search_result    res;
-            if ( search( res, val, compare_functor()) ) {
+            if ( search( res, val, compare_functor())) {
                 assert( res.pLeaf );
                 m_Stat.onFindSuccess();
                 return guarded_ptr( res.guards.release( search_result::Guard_Leaf ));

diff --git a/cds/intrusive/impl/iterable_list.h b/cds/intrusive/impl/iterable_list.h
index fa33dda7979f55e8549f6df00c15166ebb52429e..3cb3fd84e0a4feaa458582a99343eb992dbb48de 100644 (file)
--- a/cds/intrusive/impl/iterable_list.h
+++ b/cds/intrusive/impl/iterable_list.h
@@ -847,7 +847,7 @@ namespace cds { namespace intrusive {
             insert_position pos;
 
             while ( true ) {
-                if ( inserting_search( pHead, *pNode->data.load(memory_model::memory_order_relaxed).ptr(), pos, key_comparator()) ) {
+                if ( inserting_search( pHead, *pNode->data.load(memory_model::memory_order_relaxed).ptr(), pos, key_comparator())) {
                     m_Stat.onInsertFailed();
                     return false;
                 }
@@ -891,7 +891,7 @@ namespace cds { namespace intrusive {
             guard.assign( &val );
 
             while ( true ) {
-                if ( inserting_search( pHead, val, pos, key_comparator()) ) {
+                if ( inserting_search( pHead, val, pos, key_comparator())) {
                     m_Stat.onInsertFailed();
                     return false;
                 }
@@ -916,7 +916,7 @@ namespace cds { namespace intrusive {
             guard.assign( &val );
 
             while ( true ) {
-                if ( inserting_search( pHead, val, pos, key_comparator()) ) {
+                if ( inserting_search( pHead, val, pos, key_comparator())) {
                     // try to replace pCur->data with val
                     assert( pos.pFound != nullptr );
                     assert( key_comparator()(*pos.pFound, val) == 0 );

diff --git a/cds/intrusive/michael_list_rcu.h b/cds/intrusive/michael_list_rcu.h
index 3f3422da20c82bd88079fd409ba65f9712836361..0ed9252935b47ebb56a08064d3eb78042a8b44a7 100644 (file)
--- a/cds/intrusive/michael_list_rcu.h
+++ b/cds/intrusive/michael_list_rcu.h
@@ -875,7 +875,7 @@ namespace cds { namespace intrusive {
 
             marked_node_ptr p( pos.pCur );
             pNode->m_pNext.store( p, memory_model::memory_order_release );
-            if ( cds_likely( pos.pPrev->compare_exchange_strong( p, marked_node_ptr( pNode ), memory_model::memory_order_release, atomics::memory_order_relaxed )) )
+            if ( cds_likely( pos.pPrev->compare_exchange_strong( p, marked_node_ptr( pNode ), memory_model::memory_order_release, atomics::memory_order_relaxed )))
                 return true;
 
             pNode->m_pNext.store( marked_node_ptr(), memory_model::memory_order_relaxed );
@@ -897,11 +897,11 @@ namespace cds { namespace intrusive {
             // Mark the node (logical deletion)
             marked_node_ptr next( pos.pNext, 0 );
 
-            if ( cds_likely( pos.pCur->m_pNext.compare_exchange_strong( next, next | nMask, memory_model::memory_order_release, atomics::memory_order_relaxed )) ) {
+            if ( cds_likely( pos.pCur->m_pNext.compare_exchange_strong( next, next | nMask, memory_model::memory_order_release, atomics::memory_order_relaxed ))) {
 
                 // Try physical removal - fast path
                 marked_node_ptr cur( pos.pCur );
-                if ( cds_likely( pos.pPrev->compare_exchange_strong( cur, marked_node_ptr( pos.pNext ), memory_model::memory_order_acquire, atomics::memory_order_relaxed )) ) {
+                if ( cds_likely( pos.pPrev->compare_exchange_strong( cur, marked_node_ptr( pos.pNext ), memory_model::memory_order_acquire, atomics::memory_order_relaxed ))) {
                     if ( nMask == erase_mask )
                         link_to_remove_chain( pos, pos.pCur );
                 }
@@ -1243,7 +1243,7 @@ namespace cds { namespace intrusive {
             assert( gc::is_locked());
 
             while ( true ) {
-                if ( search( pos.refHead, val, pos, key_comparator()) ) {
+                if ( search( pos.refHead, val, pos, key_comparator())) {
                     assert( key_comparator()( val, *node_traits::to_value_ptr( *pos.pCur )) == 0 );
 
                     func( false, *node_traits::to_value_ptr( *pos.pCur ), val );

diff --git a/cds/intrusive/michael_set_nogc.h b/cds/intrusive/michael_set_nogc.h
index 9aeb8468686b95fcc3f83b790bae0072614c219d..bea9ee568c73ed5f39028a991c83888d67b10a9f 100644 (file)
--- a/cds/intrusive/michael_set_nogc.h
+++ b/cds/intrusive/michael_set_nogc.h
@@ -225,7 +225,7 @@ namespace cds { namespace intrusive {
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set
             size_t nLoadFactor      ///< load factor: estimation of max number of items in the bucket
         ) : m_nHashBitmask( michael_set::details::init_hash_bitmask( nMaxItemCount, nLoadFactor ))
-          , m_Buckets( bucket_table_allocator().allocate( bucket_count()) )
+          , m_Buckets( bucket_table_allocator().allocate( bucket_count()))
         {
             for ( auto it = m_Buckets, itEnd = m_Buckets + bucket_count(); it != itEnd; ++it )
                 construct_bucket<bucket_stat>( it );

diff --git a/cds/intrusive/michael_set_rcu.h b/cds/intrusive/michael_set_rcu.h
index ab80e74e00cf7482568a27ef7e029229c29001e2..bbf53cc1d34b5c5c157a7070245a8261b8418b00 100644 (file)
--- a/cds/intrusive/michael_set_rcu.h
+++ b/cds/intrusive/michael_set_rcu.h
@@ -263,7 +263,7 @@ namespace cds { namespace intrusive {
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set
             size_t nLoadFactor      ///< load factor: average size of the bucket
         ) : m_nHashBitmask( michael_set::details::init_hash_bitmask( nMaxItemCount, nLoadFactor ))
-          , m_Buckets( bucket_table_allocator().allocate( bucket_count()) )
+          , m_Buckets( bucket_table_allocator().allocate( bucket_count()))
         {
             for ( auto it = m_Buckets, itEnd = m_Buckets + bucket_count(); it != itEnd; ++it )
                 construct_bucket<bucket_stat>( it );

diff --git a/cds/intrusive/striped_set/boost_unordered_set.h b/cds/intrusive/striped_set/boost_unordered_set.h
index f612b372fdfd8b2e7ff45d17b49fc8340d19eb81..5ff616d5b185b4842c3310b5e11561bcacf3866e 100644 (file)
--- a/cds/intrusive/striped_set/boost_unordered_set.h
+++ b/cds/intrusive/striped_set/boost_unordered_set.h
@@ -93,7 +93,7 @@ namespace cds { namespace intrusive { namespace striped_set {
 
             public:
                 adapted_container()
-                    : m_Set( typename container_type::bucket_traits( m_Buckets.buffer(), m_Buckets.capacity()) )
+                    : m_Set( typename container_type::bucket_traits( m_Buckets.buffer(), m_Buckets.capacity()))
                 {}
 
                 container_type& base_container()

diff --git a/cds/memory/michael/allocator.h b/cds/memory/michael/allocator.h
index b7cea674e79f2305445ca995437e3d39d9c9ede8..4ef0f6d832fccc065eddf53df258d4dd5c66611d 100644 (file)
--- a/cds/memory/michael/allocator.h
+++ b/cds/memory/michael/allocator.h
@@ -352,7 +352,7 @@ namespace michael {
         /// Push superblock descriptor to free-list
         void push( T * pDesc )
         {
-            assert( base_class::node_algorithms::inited( static_cast<item_hook *>(pDesc)) );
+            assert( base_class::node_algorithms::inited( static_cast<item_hook *>(pDesc)));
             auto_lock al(m_access);
             base_class::push_back( *pDesc );
         }
@@ -365,7 +365,7 @@ namespace michael {
                 return nullptr;
             T& rDesc = base_class::front();
             base_class::pop_front();
-            assert( base_class::node_algorithms::inited( static_cast<item_hook *>(&rDesc)) );
+            assert( base_class::node_algorithms::inited( static_cast<item_hook *>(&rDesc)));
             return &rDesc;
         }
 
@@ -407,7 +407,7 @@ namespace michael {
         void    push( T * pDesc )
         {
             auto_lock al( m_access );
-            assert( base_class::node_algorithms::inited( static_cast<item_hook *>(pDesc)) );
+            assert( base_class::node_algorithms::inited( static_cast<item_hook *>(pDesc)));
             base_class::push_back( *pDesc );
         }
 
@@ -419,7 +419,7 @@ namespace michael {
                 return nullptr;
             T& rDesc = base_class::front();
             base_class::pop_front();
-            assert( base_class::node_algorithms::inited( static_cast<item_hook *>(&rDesc)) );
+            assert( base_class::node_algorithms::inited( static_cast<item_hook *>(&rDesc)));
             return &rDesc;
         }
 
@@ -429,7 +429,7 @@ namespace michael {
             assert(pDesc != nullptr);
             auto_lock al( m_access );
             // !inited(pDesc) is equal to "pDesc is being linked to partial list"
-            if ( !base_class::node_algorithms::inited( static_cast<item_hook *>(pDesc)) ) {
+            if ( !base_class::node_algorithms::inited( static_cast<item_hook *>(pDesc))) {
                 base_class::erase( base_class::iterator_to( *pDesc ));
                 return true;
             }
@@ -1146,7 +1146,7 @@ namespace michael {
                 } while ( !pPartial.compare_exchange_weak( pDesc, nullptr, atomics::memory_order_release, atomics::memory_order_relaxed ));
 
                 //assert( pDesc == nullptr || free_desc_list<superblock_desc>::node_algorithms::inited( static_cast<sb_free_list_hook *>(pDesc)));
-                //assert( pDesc == nullptr || partial_desc_list<superblock_desc>::node_algorithms::inited( static_cast<sb_partial_list_hook *>(pDesc)) );
+                //assert( pDesc == nullptr || partial_desc_list<superblock_desc>::node_algorithms::inited( static_cast<sb_partial_list_hook *>(pDesc)));
                 return pDesc;
             }
 
@@ -1154,7 +1154,7 @@ namespace michael {
             void add_partial( superblock_desc * pDesc )
             {
                 assert( pPartial != pDesc );
-                //assert( partial_desc_list<superblock_desc>::node_algorithms::inited( static_cast<sb_partial_list_hook *>(pDesc)) );
+                //assert( partial_desc_list<superblock_desc>::node_algorithms::inited( static_cast<sb_partial_list_hook *>(pDesc)));
 
                 superblock_desc * pCur = nullptr;
                 if ( !pPartial.compare_exchange_strong(pCur, pDesc, atomics::memory_order_acq_rel, atomics::memory_order_relaxed))

diff --git a/cds/sync/spinlock.h b/cds/sync/spinlock.h
index 1708bba0c4abc8f2a37b5209877cdc943d8495cb..ec0ee5cfbb6055f8d93d35af09c8e6a9924d6b05 100644 (file)
--- a/cds/sync/spinlock.h
+++ b/cds/sync/spinlock.h
@@ -145,7 +145,7 @@ namespace cds {
                 Returns \p true if locking is succeeded
                 otherwise (if the spin is already locked) returns \p false
             */
-            bool try_lock( unsigned int nTryCount ) CDS_NOEXCEPT_( noexcept( backoff_strategy()()) )
+            bool try_lock( unsigned int nTryCount ) CDS_NOEXCEPT_( noexcept( backoff_strategy()()))
             {
                 backoff_strategy backoff;
                 while ( nTryCount-- ) {
@@ -340,7 +340,7 @@ namespace cds {
             /// Unlock the spin-lock. Return \p true if the current thread is owner of spin-lock \p false otherwise
             bool unlock() CDS_NOEXCEPT
             {
-                if ( is_taken( OS::get_current_thread_id()) ) {
+                if ( is_taken( OS::get_current_thread_id())) {
                     integral_type n = m_spin.load( atomics::memory_order_relaxed );
                     if ( n > 1 )
                         m_spin.store( n - 1, atomics::memory_order_relaxed );
@@ -356,7 +356,7 @@ namespace cds {
             /// Change the owner of locked spin-lock. May be called by thread that is owner of the spin-lock
             bool change_owner( OS::ThreadId newOwnerId ) CDS_NOEXCEPT
             {
-                if ( is_taken( OS::get_current_thread_id()) ) {
+                if ( is_taken( OS::get_current_thread_id())) {
                     assert( newOwnerId != OS::c_NullThreadId );
                     m_OwnerId = newOwnerId;
                     return true;

diff --git a/test/stress/map/delodd/map_delodd.cpp b/test/stress/map/delodd/map_delodd.cpp
index 7419144f7a33665001524126d8396a5a0e4067fd..15c213dc4cb7677cda389f7e9e2c119ccce3c8c6 100644 (file)
--- a/test/stress/map/delodd/map_delodd.cpp
+++ b/test/stress/map/delodd/map_delodd.cpp
@@ -119,5 +119,5 @@ namespace map {
         return lf;
     }
 
-    INSTANTIATE_TEST_CASE_P( a, Map_DelOdd_LF, ::testing::ValuesIn( Map_DelOdd_LF::get_load_factors()) );
+    INSTANTIATE_TEST_CASE_P( a, Map_DelOdd_LF, ::testing::ValuesIn( Map_DelOdd_LF::get_load_factors()));
 } // namespace map

diff --git a/test/stress/map/delodd/map_delodd.h b/test/stress/map/delodd/map_delodd.h
index 623068969c5da0564c8ed59a660c9794e2d2a1ee..3e5cebd338601d3a09ca1af448ebc76c556180ad 100644 (file)
--- a/test/stress/map/delodd/map_delodd.h
+++ b/test/stress/map/delodd/map_delodd.h
@@ -685,7 +685,7 @@ namespace map {
             {
                 for ( size_t n = 0; n < s_nMapSize; n +=2 ) {
                     for ( size_t i = 0; i < s_nInsThreadCount; ++i ) {
-                        EXPECT_TRUE( testMap.contains( key_type( n, i )) ) << "key=" << n << "/" << i;
+                        EXPECT_TRUE( testMap.contains( key_type( n, i ))) << "key=" << n << "/" << i;
                     }
                 }
             }

diff --git a/test/stress/map/find_int/map_find_int.cpp b/test/stress/map/find_int/map_find_int.cpp
index 88bff4f6d9e6890a95ba88e29cfa0ec2531f9aea..e0f404960d9d4fb44dea37710c939fcc06230a8d 100644 (file)
--- a/test/stress/map/find_int/map_find_int.cpp
+++ b/test/stress/map/find_int/map_find_int.cpp
@@ -128,5 +128,5 @@ namespace map {
         return lf;
     }
 
-    INSTANTIATE_TEST_CASE_P( a, Map_find_int_LF, ::testing::ValuesIn( Map_find_int_LF::get_load_factors()) );
+    INSTANTIATE_TEST_CASE_P( a, Map_find_int_LF, ::testing::ValuesIn( Map_find_int_LF::get_load_factors()));
 } // namespace map

diff --git a/test/stress/map/find_string/map_find_string.cpp b/test/stress/map/find_string/map_find_string.cpp
index 51cee8d180f86cf92f121af2537fb079d64fffe4..27bff50d64b95a52130e83a0107a8759388015a8 100644 (file)
--- a/test/stress/map/find_string/map_find_string.cpp
+++ b/test/stress/map/find_string/map_find_string.cpp
@@ -195,5 +195,5 @@ namespace map {
         return lf;
     }
 
-    INSTANTIATE_TEST_CASE_P( a, Map_find_string_LF, ::testing::ValuesIn( Map_find_string::get_load_factors()) );
+    INSTANTIATE_TEST_CASE_P( a, Map_find_string_LF, ::testing::ValuesIn( Map_find_string::get_load_factors()));
 } // namespace map

diff --git a/test/stress/map/map_type_std.h b/test/stress/map/map_type_std.h
index 0f3c00598152e70812044bf752e992f9b35b1dae..ad4fe57eb652098cd9ba328f01d5be6d1f92471a 100644 (file)
--- a/test/stress/map/map_type_std.h
+++ b/test/stress/map/map_type_std.h
@@ -80,7 +80,7 @@ namespace map {
         bool insert( const Key& key, const T& val, Func func )
         {
             scoped_lock al( m_lock );
-            std::pair<typename base_class::iterator, bool> pRet = base_class::insert( typename base_class::value_type( key, Value()) );
+            std::pair<typename base_class::iterator, bool> pRet = base_class::insert( typename base_class::value_type( key, Value()));
             if ( pRet.second ) {
                 func( pRet.first->second, val );
                 return true;
@@ -92,7 +92,7 @@ namespace map {
         std::pair<bool, bool> update( const T& key, Func func, bool /*bAllowInsert*/ = true )
         {
             scoped_lock al( m_lock );
-            std::pair<typename base_class::iterator, bool> pRet = base_class::insert( typename base_class::value_type( key, Value()) );
+            std::pair<typename base_class::iterator, bool> pRet = base_class::insert( typename base_class::value_type( key, Value()));
             if ( pRet.second ) {
                 func( true, *pRet.first );
                 return std::make_pair( true, true );

diff --git a/test/stress/queue/intrusive_push_pop.cpp b/test/stress/queue/intrusive_push_pop.cpp
index a3a7c5b87c68cb6cf7d86aabc85c97e40f7bed28..8c8c743c930238d9887132a21cfbb50d01464d95 100644 (file)
--- a/test/stress/queue/intrusive_push_pop.cpp
+++ b/test/stress/queue/intrusive_push_pop.cpp
@@ -514,6 +514,6 @@ namespace {
 
     INSTANTIATE_TEST_CASE_P( SQ,
         intrusive_segmented_queue_push_pop,
-        ::testing::ValuesIn( intrusive_segmented_queue_push_pop::get_test_parameters()) );
+        ::testing::ValuesIn( intrusive_segmented_queue_push_pop::get_test_parameters()));
 
 } // namespace

diff --git a/test/stress/set/delodd/set_delodd.cpp b/test/stress/set/delodd/set_delodd.cpp
index b2d43292ae0d8c391f82230876441fab18fad9ce..0a3332e1af92d8cf3dbac2f9f89ab44a7304478e 100644 (file)
--- a/test/stress/set/delodd/set_delodd.cpp
+++ b/test/stress/set/delodd/set_delodd.cpp
@@ -112,5 +112,5 @@ namespace set {
         return lf;
     }
 
-    INSTANTIATE_TEST_CASE_P( a, Set_DelOdd_LF, ::testing::ValuesIn( Set_DelOdd_LF::get_load_factors()) );
+    INSTANTIATE_TEST_CASE_P( a, Set_DelOdd_LF, ::testing::ValuesIn( Set_DelOdd_LF::get_load_factors()));
 } // namespace set

diff --git a/test/unit/intrusive-set/test_intrusive_feldman_hashset.h b/test/unit/intrusive-set/test_intrusive_feldman_hashset.h
index c0e16d23f529e79c89236363d217d3432df9a9ce..1409e8a9a29b711667477963c4fe6a83a53e86b4 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_feldman_hashset.h
+++ b/test/unit/intrusive-set/test_intrusive_feldman_hashset.h
@@ -241,7 +241,7 @@ namespace cds_test {
                     break;
                 case 1:
                     ASSERT_TRUE( s.erase( i.key()));
-                    ASSERT_FALSE( s.erase( i.key()) );
+                    ASSERT_FALSE( s.erase( i.key()));
                     break;
                 case 2:
                     EXPECT_EQ( i.nEraseCount, 0u );

diff --git a/test/unit/intrusive-set/test_intrusive_feldman_hashset_hp.h b/test/unit/intrusive-set/test_intrusive_feldman_hashset_hp.h
index e5b1507d6ac8034fbaecd9fc5d4223aeb68cd227..49dfb733457a6cafe82dadb43e31e75aca678701 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_feldman_hashset_hp.h
+++ b/test/unit/intrusive-set/test_intrusive_feldman_hashset_hp.h
@@ -60,7 +60,7 @@ namespace cds_test {
             data.reserve( nSetSize );
             indices.reserve( nSetSize );
             for ( size_t key = 0; key < nSetSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/intrusive-set/test_intrusive_feldman_hashset_rcu.h b/test/unit/intrusive-set/test_intrusive_feldman_hashset_rcu.h
index d8f795d547b04ca3a05e8bb2f95c23130161ea44..6b5c1fc270055ebc08f42dafc84afb9db0871b2a 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_feldman_hashset_rcu.h
+++ b/test/unit/intrusive-set/test_intrusive_feldman_hashset_rcu.h
@@ -65,7 +65,7 @@ protected:
         data.reserve( nSetSize );
         indices.reserve( nSetSize );
         for ( size_t key = 0; key < nSetSize; ++key ) {
-            data.push_back( value_type( static_cast<int>(key)) );
+            data.push_back( value_type( static_cast<int>(key)));
             indices.push_back( key );
         }
         shuffle( indices.begin(), indices.end());

diff --git a/test/unit/intrusive-set/test_intrusive_michael_iterable.h b/test/unit/intrusive-set/test_intrusive_michael_iterable.h
index 3af0cbe506975b07689ff8448d97f031345eb7df..ef0fca48c2ae726edbf83a2fc095b75cdf5ad0a1 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_michael_iterable.h
+++ b/test/unit/intrusive-set/test_intrusive_michael_iterable.h
@@ -312,7 +312,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()));
                 EXPECT_EQ( i.nFindCount, 0u );
                 ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } ));
                 EXPECT_EQ( i.nFindCount, 1u );
@@ -333,7 +333,7 @@ namespace cds_test {
                     break;
                 case 1:
                     ASSERT_TRUE( s.erase( i.key()));
-                    ASSERT_FALSE( s.erase( i.key()) );
+                    ASSERT_FALSE( s.erase( i.key()));
                     break;
                 case 2:
                     ASSERT_TRUE( s.erase( v ));
@@ -341,7 +341,7 @@ namespace cds_test {
                     break;
                 case 3:
                     ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less()));
-                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()) );
+                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()));
                     break;
                 case 4:
                     EXPECT_EQ( i.nEraseCount, 0u );

diff --git a/test/unit/intrusive-set/test_intrusive_michael_iterable_hp.h b/test/unit/intrusive-set/test_intrusive_michael_iterable_hp.h
index cc644ab829d25b4464dbc0621002963ad52b06f7..674a36550974bf7a1aa5a62f0dde4ed536f9f212 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_michael_iterable_hp.h
+++ b/test/unit/intrusive-set/test_intrusive_michael_iterable_hp.h
@@ -65,7 +65,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/intrusive-set/test_intrusive_set.h b/test/unit/intrusive-set/test_intrusive_set.h
index b99e1fee27446864edc603858af90b9d9d1f8ce3..de18a348520627f88fbbcde56b16491801cc5b49 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_set.h
+++ b/test/unit/intrusive-set/test_intrusive_set.h
@@ -352,7 +352,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()));
                 EXPECT_EQ( i.nFindCount, 0u );
                 ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } ));
                 EXPECT_EQ( i.nFindCount, 1u );
@@ -368,7 +368,7 @@ namespace cds_test {
                     break;
                 case 1:
                     ASSERT_TRUE( s.erase( i.key()));
-                    ASSERT_FALSE( s.erase( i.key()) );
+                    ASSERT_FALSE( s.erase( i.key()));
                     break;
                 case 2:
                     ASSERT_TRUE( s.erase( v ));
@@ -376,7 +376,7 @@ namespace cds_test {
                     break;
                 case 3:
                     ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less()));
-                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()) );
+                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()));
                     break;
                 case 4:
                     EXPECT_EQ( i.nEraseCount, 0u );

diff --git a/test/unit/intrusive-set/test_intrusive_set_hp.h b/test/unit/intrusive-set/test_intrusive_set_hp.h
index 90746509d8a5aa2e882fac493efb0bda2d4d0759..e9f830d9e5158c3b4613401d74d6e4148f6f46b7 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_set_hp.h
+++ b/test/unit/intrusive-set/test_intrusive_set_hp.h
@@ -65,7 +65,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/intrusive-set/test_intrusive_set_rcu.h b/test/unit/intrusive-set/test_intrusive_set_rcu.h
index bef48af808fa6c3f2fcf3cb28fa1da7cb03a67af..b3e47ce7ff4c2f38946349ff35860069cb1844d9 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_set_rcu.h
+++ b/test/unit/intrusive-set/test_intrusive_set_rcu.h
@@ -65,7 +65,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/intrusive-set/test_intrusive_split_iterable_set.h b/test/unit/intrusive-set/test_intrusive_split_iterable_set.h
index 2043306a892997a997d8af07e6566e9d6e484e2a..7d3b9cfcadcec669ed0f70d3ca38664f459f293c 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_split_iterable_set.h
+++ b/test/unit/intrusive-set/test_intrusive_split_iterable_set.h
@@ -313,7 +313,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()));
                 EXPECT_EQ( i.nFindCount, 0u );
                 ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } ));
                 EXPECT_EQ( i.nFindCount, 1u );
@@ -334,7 +334,7 @@ namespace cds_test {
                     break;
                 case 1:
                     ASSERT_TRUE( s.erase( i.key()));
-                    ASSERT_FALSE( s.erase( i.key()) );
+                    ASSERT_FALSE( s.erase( i.key()));
                     break;
                 case 2:
                     ASSERT_TRUE( s.erase( v ));
@@ -342,7 +342,7 @@ namespace cds_test {
                     break;
                 case 3:
                     ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less()));
-                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()) );
+                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()));
                     break;
                 case 4:
                     EXPECT_EQ( i.nEraseCount, 0u );

diff --git a/test/unit/intrusive-set/test_intrusive_split_iterable_set_hp.h b/test/unit/intrusive-set/test_intrusive_split_iterable_set_hp.h
index 1d634f309bd3de8abbaac3327ffd7ce5a691c62c..76b04351fb02be7d213fe939992ecba540cb0c55 100644 (file)
--- a/test/unit/intrusive-set/test_intrusive_split_iterable_set_hp.h
+++ b/test/unit/intrusive-set/test_intrusive_split_iterable_set_hp.h
@@ -65,7 +65,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/map/test_feldman_hashmap.h b/test/unit/map/test_feldman_hashmap.h
index 90ea6e309320ba0a13b636117b7cb6b958a4e165..bdde0385a11a23f9c3257fdcd396195da8497803 100644 (file)
--- a/test/unit/map/test_feldman_hashmap.h
+++ b/test/unit/map/test_feldman_hashmap.h
@@ -104,8 +104,8 @@ namespace cds_test {
                     } ));
                     break;
                 case 2:
-                    ASSERT_TRUE( m.insert( std::to_string( i.nKey )) );
-                    ASSERT_FALSE( m.insert( std::to_string( i.nKey )) );
+                    ASSERT_TRUE( m.insert( std::to_string( i.nKey )));
+                    ASSERT_FALSE( m.insert( std::to_string( i.nKey )));
                     ASSERT_TRUE( m.find( i.nKey, []( map_pair& v ) {
                         v.second.nVal = v.first.nKey;
                         v.second.strVal = std::to_string( v.first.nKey );
@@ -234,20 +234,20 @@ namespace cds_test {
                 case 14:
                 {
                     std::string str = val.strVal;
-                    ASSERT_TRUE( m.emplace( i, std::move( str )) );
+                    ASSERT_TRUE( m.emplace( i, std::move( str )));
                     ASSERT_TRUE( str.empty());
                     str = val.strVal;
-                    ASSERT_FALSE( m.emplace( i, std::move( str )) );
+                    ASSERT_FALSE( m.emplace( i, std::move( str )));
                     ASSERT_TRUE( str.empty());
                 }
                 break;
                 case 15:
                 {
                     std::string str = val.strVal;
-                    ASSERT_TRUE( m.emplace( i, i.nKey, std::move( str )) );
+                    ASSERT_TRUE( m.emplace( i, i.nKey, std::move( str )));
                     ASSERT_TRUE( str.empty());
                     str = val.strVal;
-                    ASSERT_FALSE( m.emplace( i, i.nKey, std::move( str )) );
+                    ASSERT_FALSE( m.emplace( i, i.nKey, std::move( str )));
                     ASSERT_TRUE( str.empty());
                 }
                 break;

diff --git a/test/unit/pqueue/mspqueue.cpp b/test/unit/pqueue/mspqueue.cpp
index e378e42cd192b5cb2abab00a88395561fa6c8684..3d726abe4d7689ee2718ba8a068f72b9fb83b642 100644 (file)
--- a/test/unit/pqueue/mspqueue.cpp
+++ b/test/unit/pqueue/mspqueue.cpp
@@ -74,7 +74,7 @@ namespace {
                     ASSERT_TRUE( pq.emplace( p->k, p->v ));
                     break;
                 case 2:
-                    ASSERT_TRUE( pq.emplace( std::make_pair( p->k, p->v )) );
+                    ASSERT_TRUE( pq.emplace( std::make_pair( p->k, p->v )));
                     break;
                 default:
                     ASSERT_TRUE( pq.push( *p ));

diff --git a/test/unit/queue/test_bounded_queue.h b/test/unit/queue/test_bounded_queue.h
index 18cb423eac5133dd1b1f1f54efc92913f785809a..4edb773d5d8140f43647dc0c3306195bd037ff4a 100644 (file)
--- a/test/unit/queue/test_bounded_queue.h
+++ b/test/unit/queue/test_bounded_queue.h
@@ -114,7 +114,7 @@ namespace cds_test {
             ASSERT_CONTAINER_SIZE( q, 0u );
 
             for ( size_t i = 0; i < nSize; ++i ) {
-                ASSERT_TRUE( q.push( static_cast<value_type>(i)) );
+                ASSERT_TRUE( q.push( static_cast<value_type>(i)));
             }
             ASSERT_FALSE( q.empty());
             ASSERT_CONTAINER_SIZE( q, nSize );

diff --git a/test/unit/queue/test_generic_queue.h b/test/unit/queue/test_generic_queue.h
index 67ed8075ae568c6bfb89edad2ec77a231501ca53..eec329d19a9880d62cac3a524a10ae300f552841 100644 (file)
--- a/test/unit/queue/test_generic_queue.h
+++ b/test/unit/queue/test_generic_queue.h
@@ -115,7 +115,7 @@ namespace cds_test {
 
             // clear
             for ( size_t i = 0; i < nSize; ++i ) {
-                ASSERT_TRUE( q.push( static_cast<value_type>(i)) );
+                ASSERT_TRUE( q.push( static_cast<value_type>(i)));
             }
             ASSERT_FALSE( q.empty());
             ASSERT_CONTAINER_SIZE( q, nSize );

diff --git a/test/unit/queue/test_segmented_queue.h b/test/unit/queue/test_segmented_queue.h
index db0e66da3a05fa0e41bd5ad78b71451de6454e3c..94e02921b7a164beae395db72ea18537f4baf53f 100644 (file)
--- a/test/unit/queue/test_segmented_queue.h
+++ b/test/unit/queue/test_segmented_queue.h
@@ -140,7 +140,7 @@ namespace cds_test {
 
             // clear
             for ( size_t i = 0; i < nSize; ++i ) {
-                ASSERT_TRUE( q.push( static_cast<value_type>(i)) );
+                ASSERT_TRUE( q.push( static_cast<value_type>(i)));
             }
             ASSERT_FALSE( q.empty());
             ASSERT_CONTAINER_SIZE( q, nSize );

diff --git a/test/unit/set/test_feldman_hashset.h b/test/unit/set/test_feldman_hashset.h
index b6cb41b7d12504fe09ba8219701fa0b8220c28d6..4536455d36f24968abb8b5cd620983804bd589de 100644 (file)
--- a/test/unit/set/test_feldman_hashset.h
+++ b/test/unit/set/test_feldman_hashset.h
@@ -210,7 +210,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());
@@ -322,12 +322,12 @@ namespace cds_test {
                         } ));
                         break;
                 case 6:
-                    ASSERT_TRUE( s.emplace( i.key()) );
-                    ASSERT_TRUE( s.contains( i.key()) );
+                    ASSERT_TRUE( s.emplace( i.key()));
+                    ASSERT_TRUE( s.contains( i.key()));
                     break;
                 case 7:
                     str = "Hello!";
-                    ASSERT_TRUE( s.emplace( i.key(), std::move( str )) );
+                    ASSERT_TRUE( s.emplace( i.key(), std::move( str )));
                     EXPECT_TRUE( str.empty());
                     ASSERT_TRUE( s.find( i.key(), []( value_type const& v )
                     {
@@ -360,8 +360,8 @@ namespace cds_test {
                 int nKey = i.key() - 1;
                 switch ( idx % 2 ) {
                 case 0:
-                    ASSERT_TRUE( s.erase( i.key()) );
-                    ASSERT_FALSE( s.erase( i.key()) );
+                    ASSERT_TRUE( s.erase( i.key()));
+                    ASSERT_FALSE( s.erase( i.key()));
                     break;
                 case 1:
                     ASSERT_TRUE( s.erase( i.key(), [&nKey]( value_type const& v )

diff --git a/test/unit/set/test_feldman_hashset_hp.h b/test/unit/set/test_feldman_hashset_hp.h
index 805e5a79e21c3d491f75df42e481f87a81404e3a..0df10297d853180b25423f3e76c572dde9163aff 100644 (file)
--- a/test/unit/set/test_feldman_hashset_hp.h
+++ b/test/unit/set/test_feldman_hashset_hp.h
@@ -59,7 +59,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/set/test_feldman_hashset_rcu.h b/test/unit/set/test_feldman_hashset_rcu.h
index bf75929947394886bc752d1dccad92d8c725b6bf..2ecc1bfdc004742aa5835c7b3469c7d1fad8dc83 100644 (file)
--- a/test/unit/set/test_feldman_hashset_rcu.h
+++ b/test/unit/set/test_feldman_hashset_rcu.h
@@ -66,7 +66,7 @@ namespace {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/set/test_michael_iterable.h b/test/unit/set/test_michael_iterable.h
index 3a45bc24a21ec9ba48f1a47b1816f6a1941faf9c..196bffa6cd3f40f96efa72b0142fae630fc16f4f 100644 (file)
--- a/test/unit/set/test_michael_iterable.h
+++ b/test/unit/set/test_michael_iterable.h
@@ -55,7 +55,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());
@@ -254,7 +254,7 @@ namespace cds_test {
 
                 EXPECT_TRUE( s.contains( i.nKey ));
                 EXPECT_TRUE( s.contains( i ));
-                EXPECT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                EXPECT_TRUE( s.contains( other_item( i.key()), other_less()));
                 EXPECT_TRUE( s.find( i.nKey, []( value_type&, int ) {} ));
                 EXPECT_TRUE( s.find( i, []( value_type&, value_type const& ) {} ));
                 EXPECT_TRUE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} ));
@@ -273,7 +273,7 @@ namespace cds_test {
 
                 EXPECT_TRUE( s.contains( i.nKey ));
                 EXPECT_TRUE( s.contains( i ));
-                EXPECT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                EXPECT_TRUE( s.contains( other_item( i.key()), other_less()));
                 EXPECT_TRUE( s.find( i.nKey, []( value_type& v, int )
                     {
                         v.nFindCount = 1;
@@ -299,7 +299,7 @@ namespace cds_test {
                     break;
                 case 2:
                     EXPECT_TRUE( s.erase_with( other_item( i.key()), other_less()));
-                    EXPECT_FALSE( s.erase_with( other_item( i.key()), other_less()) );
+                    EXPECT_FALSE( s.erase_with( other_item( i.key()), other_less()));
                     break;
                 case 3:
                     EXPECT_TRUE( s.erase( i.key(), [&nKey]( value_type const& v )

diff --git a/test/unit/set/test_michael_iterable_hp.h b/test/unit/set/test_michael_iterable_hp.h
index ba0679b97827d29efe318d2ea17b715f8f30ca3e..4810ed77a1f5ae620e7f243c23c17b5c09210f18 100644 (file)
--- a/test/unit/set/test_michael_iterable_hp.h
+++ b/test/unit/set/test_michael_iterable_hp.h
@@ -59,7 +59,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/set/test_ordered_set_hp.h b/test/unit/set/test_ordered_set_hp.h
index cc562c996aa92aa057f6fb1398535d7d14ddfd54..6bbf7865dc1302a59e81ee137b9ca79846329cc9 100644 (file)
--- a/test/unit/set/test_ordered_set_hp.h
+++ b/test/unit/set/test_ordered_set_hp.h
@@ -59,7 +59,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/set/test_set.h b/test/unit/set/test_set.h
index 946e605afb0c8c3ca1078235785a40f8e87f94e5..a2ed58621d7d8ddd629c99e59594a206fea91e19 100644 (file)
--- a/test/unit/set/test_set.h
+++ b/test/unit/set/test_set.h
@@ -57,7 +57,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());
@@ -200,7 +200,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()));
                 ASSERT_TRUE( s.find( i.nKey, []( value_type&, int ) {} ));
                 ASSERT_TRUE( s.find( i, []( value_type&, value_type const& ) {} ));
                 ASSERT_TRUE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} ));
@@ -216,7 +216,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()));
                 ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int )
                     {
                         v.nFindCount = 1;
@@ -242,7 +242,7 @@ namespace cds_test {
                     break;
                 case 2:
                     ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less()));
-                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()) );
+                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()));
                     break;
                 case 3:
                     ASSERT_TRUE( s.erase( i.key(), [&nKey]( value_type const& v )

diff --git a/test/unit/set/test_set_hp.h b/test/unit/set/test_set_hp.h
index 03f1c270cbd85a9aa5514ce5f96242afd64c3512..cefce05620e9f9674492664c54b37f353a077f60 100644 (file)
--- a/test/unit/set/test_set_hp.h
+++ b/test/unit/set/test_set_hp.h
@@ -59,7 +59,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/set/test_set_nogc.h b/test/unit/set/test_set_nogc.h
index 7eb805d97c5f5cefeacb148f2f1e4cd0580b1a4a..f6aad21c82ebcef9186509610c041cc0d2390701 100644 (file)
--- a/test/unit/set/test_set_nogc.h
+++ b/test/unit/set/test_set_nogc.h
@@ -240,7 +240,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/set/test_set_rcu.h b/test/unit/set/test_set_rcu.h
index 4d0399784eab95cf7f9adbccc7998af4b37d550e..e15edc5a8f13bbf6d6c94be52523708f0fa4f881 100644 (file)
--- a/test/unit/set/test_set_rcu.h
+++ b/test/unit/set/test_set_rcu.h
@@ -59,7 +59,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/set/test_skiplist_rcu.h b/test/unit/set/test_skiplist_rcu.h
index 15220f7635bf856b7d24a120b5626c288060008b..6b0479e9f9d7ab12340a301a175091c91722ad0f 100644 (file)
--- a/test/unit/set/test_skiplist_rcu.h
+++ b/test/unit/set/test_skiplist_rcu.h
@@ -62,7 +62,7 @@ protected:
         data.reserve( nSetSize );
         indices.reserve( nSetSize );
         for ( size_t key = 0; key < nSetSize; ++key ) {
-            data.push_back( value_type( static_cast<int>(key)) );
+            data.push_back( value_type( static_cast<int>(key)));
             indices.push_back( key );
         }
         shuffle( indices.begin(), indices.end());

diff --git a/test/unit/set/test_split_iterable.h b/test/unit/set/test_split_iterable.h
index 635682dea2206b22c17414ae38cb2a0d2eeacd58..a4a0c79fe396dc8deebb1286c41e983b2bf2297d 100644 (file)
--- a/test/unit/set/test_split_iterable.h
+++ b/test/unit/set/test_split_iterable.h
@@ -57,7 +57,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());
@@ -254,7 +254,7 @@ namespace cds_test {
 
                 EXPECT_TRUE( s.contains( i.nKey ));
                 EXPECT_TRUE( s.contains( i ));
-                EXPECT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                EXPECT_TRUE( s.contains( other_item( i.key()), other_less()));
                 EXPECT_TRUE( s.find( i.nKey, []( value_type&, int ) {} ));
                 EXPECT_TRUE( s.find( i, []( value_type&, value_type const& ) {} ));
                 EXPECT_TRUE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} ));
@@ -278,7 +278,7 @@ namespace cds_test {
 
                 EXPECT_TRUE( s.contains( i.nKey ));
                 EXPECT_TRUE( s.contains( i ));
-                EXPECT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                EXPECT_TRUE( s.contains( other_item( i.key()), other_less()));
                 EXPECT_TRUE( s.find( i.nKey, []( value_type& v, int )
                     {
                         v.nFindCount = 1;
@@ -312,7 +312,7 @@ namespace cds_test {
                     break;
                 case 2:
                     EXPECT_TRUE( s.erase_with( other_item( i.key()), other_less()));
-                    EXPECT_FALSE( s.erase_with( other_item( i.key()), other_less()) );
+                    EXPECT_FALSE( s.erase_with( other_item( i.key()), other_less()));
                     break;
                 case 3:
                     EXPECT_TRUE( s.erase( i.key(), [&nKey]( value_type const& v )

diff --git a/test/unit/set/test_split_iterable_hp.h b/test/unit/set/test_split_iterable_hp.h
index 4003f0660c875182763c15e3953359a10367ef85..7f6174e3ded5ba568c73ee0a6630c48e7f74d39a 100644 (file)
--- a/test/unit/set/test_split_iterable_hp.h
+++ b/test/unit/set/test_split_iterable_hp.h
@@ -59,7 +59,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/striped-set/test_intrusive_set.h b/test/unit/striped-set/test_intrusive_set.h
index 6e105052cf49d4c803f763ef57dcafc8fbba11ca..036ad7100e01fde32d084c0052fedae69864ae0d 100644 (file)
--- a/test/unit/striped-set/test_intrusive_set.h
+++ b/test/unit/striped-set/test_intrusive_set.h
@@ -421,7 +421,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_predicate()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_predicate()));
                 EXPECT_EQ( i.nFindCount, 0u );
                 ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } ));
                 EXPECT_EQ( i.nFindCount, 1u );
@@ -437,7 +437,7 @@ namespace cds_test {
                     break;
                 case 1:
                     ASSERT_TRUE( s.erase( i.key()));
-                    ASSERT_FALSE( s.erase( i.key()) );
+                    ASSERT_FALSE( s.erase( i.key()));
                     break;
                 case 2:
                     ASSERT_TRUE( s.erase( v ));
@@ -445,7 +445,7 @@ namespace cds_test {
                     break;
                 case 3:
                     ASSERT_TRUE( s.erase_with( other_item( i.key()), other_predicate()));
-                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_predicate()) );
+                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_predicate()));
                     break;
                 case 4:
                     EXPECT_EQ( i.nEraseCount, 0u );

diff --git a/test/unit/striped-set/test_set.h b/test/unit/striped-set/test_set.h
index 7f648f1fc98b4053d4ea0980b4084d55eb75058b..1deefc3f8f26a16607e403a8b1765a28f850f505 100644 (file)
--- a/test/unit/striped-set/test_set.h
+++ b/test/unit/striped-set/test_set.h
@@ -299,7 +299,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());
@@ -442,7 +442,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_predicate()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_predicate()));
                 ASSERT_TRUE( s.find( i.nKey, []( value_type&, int ) {} ));
                 ASSERT_TRUE( s.find( i, []( value_type&, value_type const& ) {} ));
                 ASSERT_TRUE( s.find_with( other_item( i.key()), other_predicate(), []( value_type&, other_item const& ) {} ));
@@ -458,7 +458,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_predicate()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_predicate()));
                 ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int )
                     {
                         v.nFindCount = 1;
@@ -484,7 +484,7 @@ namespace cds_test {
                     break;
                 case 2:
                     ASSERT_TRUE( s.erase_with( other_item( i.key()), other_predicate()));
-                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_predicate()) );
+                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_predicate()));
                     break;
                 case 3:
                     ASSERT_TRUE( s.erase( i.key(), [&nKey]( value_type const& v )

diff --git a/test/unit/striped-set/test_striped_set.h b/test/unit/striped-set/test_striped_set.h
index 62267155bf81ecdf4bc4ce716b8991cecb6dca57..a25d72fdc8c960a5b458011e7f7e23e7e9527989 100644 (file)
--- a/test/unit/striped-set/test_striped_set.h
+++ b/test/unit/striped-set/test_striped_set.h
@@ -144,7 +144,7 @@ namespace {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());
@@ -183,8 +183,8 @@ namespace {
                     EXPECT_FALSE( updResult.second );
                     break;
                 case 1:
-                    ASSERT_TRUE( s.insert( i.key()) );
-                    ASSERT_FALSE( s.insert( i.key()) );
+                    ASSERT_TRUE( s.insert( i.key()));
+                    ASSERT_FALSE( s.insert( i.key()));
                     updResult = s.update( i.key(), []( bool bNew, value_type& val, int arg )
                     {
                         EXPECT_FALSE( bNew );
@@ -262,7 +262,7 @@ namespace {
                     } ));
                     break;
                 case 6:
-                    ASSERT_TRUE( s.emplace( i.key()) );
+                    ASSERT_TRUE( s.emplace( i.key()));
                     ASSERT_TRUE( s.find( i, []( value_type const& v, value_type const& arg )
                     {
                         EXPECT_EQ( v.key(), arg.key());
@@ -271,7 +271,7 @@ namespace {
                     break;
                 case 7:
                     str = "Hello!";
-                    ASSERT_TRUE( s.emplace( i.key(), std::move( str )) );
+                    ASSERT_TRUE( s.emplace( i.key(), std::move( str )));
                     EXPECT_TRUE( str.empty());
                     ASSERT_TRUE( s.find( i, []( value_type const& v, value_type const& arg )
                     {
@@ -319,8 +319,8 @@ namespace {
                 int nKey = i.key() - 1;
                 switch ( idx % 6 ) {
                 case 0:
-                    ASSERT_TRUE( s.erase( i.key()) );
-                    ASSERT_FALSE( s.erase( i.key()) );
+                    ASSERT_TRUE( s.erase( i.key()));
+                    ASSERT_FALSE( s.erase( i.key()));
                     break;
                 case 1:
                     ASSERT_TRUE( s.erase( i ));

diff --git a/test/unit/tree/test_intrusive_tree.h b/test/unit/tree/test_intrusive_tree.h
index 111fe78d228b0bda031dd4c682b615159fadf01d..b33e17e7f80cfe296b617610280fa08b24fb3e61 100644 (file)
--- a/test/unit/tree/test_intrusive_tree.h
+++ b/test/unit/tree/test_intrusive_tree.h
@@ -394,7 +394,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( t.contains( i.nKey ));
                 ASSERT_TRUE( t.contains( i ));
-                ASSERT_TRUE( t.contains( other_item( i.key()), other_less()) );
+                ASSERT_TRUE( t.contains( other_item( i.key()), other_less()));
                 EXPECT_EQ( i.nFindCount, 0u );
                 ASSERT_TRUE( t.find( i.nKey, []( value_type& v, int ) { ++v.nFindCount; } ));
                 EXPECT_EQ( i.nFindCount, 1u );
@@ -410,7 +410,7 @@ namespace cds_test {
                     break;
                 case 1:
                     ASSERT_TRUE( t.erase( i.key()));
-                    ASSERT_FALSE( t.erase( i.key()) );
+                    ASSERT_FALSE( t.erase( i.key()));
                     break;
                 case 2:
                     ASSERT_TRUE( t.erase( v ));
@@ -418,7 +418,7 @@ namespace cds_test {
                     break;
                 case 3:
                     ASSERT_TRUE( t.erase_with( other_item( i.key()), other_less()));
-                    ASSERT_FALSE( t.erase_with( other_item( i.key()), other_less()) );
+                    ASSERT_FALSE( t.erase_with( other_item( i.key()), other_less()));
                     break;
                 case 4:
                     EXPECT_EQ( i.nEraseCount, 0u );

diff --git a/test/unit/tree/test_intrusive_tree_hp.h b/test/unit/tree/test_intrusive_tree_hp.h
index 926ed35d4902e59529ff7f6192df561df92e17d9..1a1325afe8d2a111224a2e26da4c78857a169fad 100644 (file)
--- a/test/unit/tree/test_intrusive_tree_hp.h
+++ b/test/unit/tree/test_intrusive_tree_hp.h
@@ -64,7 +64,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/tree/test_intrusive_tree_rcu.h b/test/unit/tree/test_intrusive_tree_rcu.h
index a430a713e0539f2a8519071ad4d5f5603c86a35f..4cae7a7dcd9ea2e0095df651e5a8a1285d8cc507 100644 (file)
--- a/test/unit/tree/test_intrusive_tree_rcu.h
+++ b/test/unit/tree/test_intrusive_tree_rcu.h
@@ -67,7 +67,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/tree/test_tree_set.h b/test/unit/tree/test_tree_set.h
index ec4c692057774f8a9fcea0cce626495691b1cfec..e69c9b404e337d9a3dec1cdac4a8f130f066a961 100644 (file)
--- a/test/unit/tree/test_tree_set.h
+++ b/test/unit/tree/test_tree_set.h
@@ -255,7 +255,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());
@@ -398,7 +398,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()));
                 ASSERT_TRUE( s.find( i.nKey, []( value_type&, int ) {} ));
                 ASSERT_TRUE( s.find( i, []( value_type&, value_type const& ) {} ));
                 ASSERT_TRUE( s.find_with( other_item( i.key()), other_less(), []( value_type&, other_item const& ) {} ));
@@ -416,7 +416,7 @@ namespace cds_test {
 
                 ASSERT_TRUE( s.contains( i.nKey ));
                 ASSERT_TRUE( s.contains( i ));
-                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()) );
+                ASSERT_TRUE( s.contains( other_item( i.key()), other_less()));
                 ASSERT_TRUE( s.find( i.nKey, []( value_type& v, int )
                     {
                         v.nFindCount = 1;
@@ -442,7 +442,7 @@ namespace cds_test {
                     break;
                 case 2:
                     ASSERT_TRUE( s.erase_with( other_item( i.key()), other_less()));
-                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()) );
+                    ASSERT_FALSE( s.erase_with( other_item( i.key()), other_less()));
                     break;
                 case 3:
                     ASSERT_TRUE( s.erase( i.key(), [&nKey]( value_type const& v )

diff --git a/test/unit/tree/test_tree_set_hp.h b/test/unit/tree/test_tree_set_hp.h
index 2e39de5cf4a81d882f624699695448526cad1fde..0d7194cbf14cb6f42d35619c0fd50d412f1a38bd 100644 (file)
--- a/test/unit/tree/test_tree_set_hp.h
+++ b/test/unit/tree/test_tree_set_hp.h
@@ -59,7 +59,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());

diff --git a/test/unit/tree/test_tree_set_rcu.h b/test/unit/tree/test_tree_set_rcu.h
index 2d90808031334c6209b68a83f3a83ebc77626615..be22a843d463cd2d60a3400b031f258831365385 100644 (file)
--- a/test/unit/tree/test_tree_set_rcu.h
+++ b/test/unit/tree/test_tree_set_rcu.h
@@ -59,7 +59,7 @@ namespace cds_test {
             data.reserve( kSize );
             indices.reserve( kSize );
             for ( size_t key = 0; key < kSize; ++key ) {
-                data.push_back( value_type( static_cast<int>(key)) );
+                data.push_back( value_type( static_cast<int>(key)));
                 indices.push_back( key );
             }
             shuffle( indices.begin(), indices.end());