Removed redundant spaces
authorkhizmax <libcds.dev@gmail.com>
Sat, 29 Oct 2016 14:39:33 +0000 (17:39 +0300)
committerkhizmax <libcds.dev@gmail.com>
Sat, 29 Oct 2016 14:39:33 +0000 (17:39 +0300)
67 files changed:
cds/container/details/make_lazy_kvlist.h
cds/container/lazy_kvlist_nogc.h
cds/container/michael_kvlist_nogc.h
cds/container/michael_list_nogc.h
cds/container/michael_map.h
cds/container/michael_set.h
cds/container/michael_set_nogc.h
cds/container/michael_set_rcu.h
cds/container/rwqueue.h
cds/container/skip_list_map_nogc.h
cds/container/striped_map.h
cds/container/striped_map/std_hash_map.h
cds/container/striped_map/std_map.h
cds/container/striped_set/adapter.h
cds/gc/details/dhp.h
cds/intrusive/impl/ellen_bintree.h
cds/intrusive/impl/iterable_list.h
cds/intrusive/michael_list_rcu.h
cds/intrusive/michael_set_nogc.h
cds/intrusive/michael_set_rcu.h
cds/intrusive/striped_set/boost_unordered_set.h
cds/memory/michael/allocator.h
cds/sync/spinlock.h
test/stress/map/delodd/map_delodd.cpp
test/stress/map/delodd/map_delodd.h
test/stress/map/find_int/map_find_int.cpp
test/stress/map/find_string/map_find_string.cpp
test/stress/map/map_type_std.h
test/stress/queue/intrusive_push_pop.cpp
test/stress/set/delodd/set_delodd.cpp
test/unit/intrusive-set/test_intrusive_feldman_hashset.h
test/unit/intrusive-set/test_intrusive_feldman_hashset_hp.h
test/unit/intrusive-set/test_intrusive_feldman_hashset_rcu.h
test/unit/intrusive-set/test_intrusive_michael_iterable.h
test/unit/intrusive-set/test_intrusive_michael_iterable_hp.h
test/unit/intrusive-set/test_intrusive_set.h
test/unit/intrusive-set/test_intrusive_set_hp.h
test/unit/intrusive-set/test_intrusive_set_rcu.h
test/unit/intrusive-set/test_intrusive_split_iterable_set.h
test/unit/intrusive-set/test_intrusive_split_iterable_set_hp.h
test/unit/map/test_feldman_hashmap.h
test/unit/pqueue/mspqueue.cpp
test/unit/queue/test_bounded_queue.h
test/unit/queue/test_generic_queue.h
test/unit/queue/test_segmented_queue.h
test/unit/set/test_feldman_hashset.h
test/unit/set/test_feldman_hashset_hp.h
test/unit/set/test_feldman_hashset_rcu.h
test/unit/set/test_michael_iterable.h
test/unit/set/test_michael_iterable_hp.h
test/unit/set/test_ordered_set_hp.h
test/unit/set/test_set.h
test/unit/set/test_set_hp.h
test/unit/set/test_set_nogc.h
test/unit/set/test_set_rcu.h
test/unit/set/test_skiplist_rcu.h
test/unit/set/test_split_iterable.h
test/unit/set/test_split_iterable_hp.h
test/unit/striped-set/test_intrusive_set.h
test/unit/striped-set/test_set.h
test/unit/striped-set/test_striped_set.h
test/unit/tree/test_intrusive_tree.h
test/unit/tree/test_intrusive_tree_hp.h
test/unit/tree/test_intrusive_tree_rcu.h
test/unit/tree/test_tree_set.h
test/unit/tree/test_tree_set_hp.h
test/unit/tree/test_tree_set_rcu.h

index dbe53f2..bc7d109 100644 (file)
@@ -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 )... )))
                 {}
             };
 
index e123b8d..6e2b2fc 100644 (file)
@@ -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>
index 43c3e1f..e43c87c 100644 (file)
@@ -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>
index 277560b..a3b881b 100644 (file)
@@ -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>
index 71287e4..7ba149e 100644 (file)
@@ -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 );
index 81823a2..e2aa8c3 100644 (file)
@@ -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 );
index a921ff4..9854ac0 100644 (file)
@@ -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 );
index 9733f4c..d2e47bc 100644 (file)
@@ -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 );
index 028a08b..ffd6adf 100644 (file)
@@ -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;
             }
index 388cf46..0740bef 100644 (file)
@@ -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
index 46ecd89..17e6462 100644 (file)
@@ -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
                                 ));
                             }
index 3f07add..884083c 100644 (file)
@@ -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 );
                 }
index 9eeca8c..f42e788 100644 (file)
@@ -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;
index 26faff5..03a5cb4 100644 (file)
@@ -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;
index 9274765..5f03cc8 100644 (file)
@@ -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
index 0321fbb..27c513f 100644 (file)
@@ -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 ));
index fa33dda..3cb3fd8 100644 (file)
@@ -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 );
index 3f3422d..0ed9252 100644 (file)
@@ -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 );
index 9aeb846..bea9ee5 100644 (file)
@@ -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 );
index ab80e74..bbf53cc 100644 (file)
@@ -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 );
index f612b37..5ff616d 100644 (file)
@@ -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()
index b7cea67..4ef0f6d 100644 (file)
@@ -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))
index 1708bba..ec0ee5c 100644 (file)
@@ -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;
index 7419144..15c213d 100644 (file)
@@ -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
index 6230689..3e5cebd 100644 (file)
@@ -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;
                     }
                 }
             }
index 88bff4f..e0f4049 100644 (file)
@@ -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
index 51cee8d..27bff50 100644 (file)
@@ -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
index 0f3c005..ad4fe57 100644 (file)
@@ -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 );
index a3a7c5b..8c8c743 100644 (file)
@@ -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
index b2d4329..0a3332e 100644 (file)
@@ -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
index c0e16d2..1409e8a 100644 (file)
@@ -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 );
index e5b1507..49dfb73 100644 (file)
@@ -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());
index d8f795d..6b5c1fc 100644 (file)
@@ -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());
index 3af0cbe..ef0fca4 100644 (file)
@@ -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 );
index cc644ab..674a365 100644 (file)
@@ -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());
index b99e1fe..de18a34 100644 (file)
@@ -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 );
index 9074650..e9f830d 100644 (file)
@@ -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());
index bef48af..b3e47ce 100644 (file)
@@ -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());
index 2043306..7d3b9cf 100644 (file)
@@ -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 );
index 1d634f3..76b0435 100644 (file)
@@ -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());
index 90ea6e3..bdde038 100644 (file)
@@ -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;
index e378e42..3d726ab 100644 (file)
@@ -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 ));
index 18cb423..4edb773 100644 (file)
@@ -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 );
index 67ed807..eec329d 100644 (file)
@@ -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 );
index db0e66d..94e0292 100644 (file)
@@ -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 );
index b6cb41b..4536455 100644 (file)
@@ -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 )
index 805e5a7..0df1029 100644 (file)
@@ -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());
index bf75929..2ecc1bf 100644 (file)
@@ -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());
index 3a45bc2..196bffa 100644 (file)
@@ -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 )
index ba0679b..4810ed7 100644 (file)
@@ -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());
index cc562c9..6bbf786 100644 (file)
@@ -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());
index 946e605..a2ed586 100644 (file)
@@ -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 )
index 03f1c27..cefce05 100644 (file)
@@ -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());
index 7eb805d..f6aad21 100644 (file)
@@ -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());
index 4d03997..e15edc5 100644 (file)
@@ -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());
index 15220f7..6b0479e 100644 (file)
@@ -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());
index 635682d..a4a0c79 100644 (file)
@@ -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 )
index 4003f06..7f6174e 100644 (file)
@@ -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());
index 6e10505..036ad71 100644 (file)
@@ -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 );
index 7f648f1..1deefc3 100644 (file)
@@ -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 )
index 6226715..a25d72f 100644 (file)
@@ -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 ));
index 111fe78..b33e17e 100644 (file)
@@ -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 );
index 926ed35..1a1325a 100644 (file)
@@ -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());
index a430a71..4cae7a7 100644 (file)
@@ -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());
index ec4c692..e69c9b4 100644 (file)
@@ -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 )
index 2e39de5..0d7194c 100644 (file)
@@ -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());
index 2d90808..be22a84 100644 (file)
@@ -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());