projects / libcds.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Removed redundant spaces
[libcds.git] / test / unit / map / test_feldman_hashmap.h
diff --git a/test/unit/map/test_feldman_hashmap.h b/test/unit/map/test_feldman_hashmap.h
index 47703c6ec01a86f005b0a6249af02aee0cb625e8..90ea6e309320ba0a13b636117b7cb6b958a4e165 100644 (file)
--- a/test/unit/map/test_feldman_hashmap.h
+++ b/test/unit/map/test_feldman_hashmap.h
@@ -5,7 +5,7 @@
 
     Source code repo: http://github.com/khizmax/libcds/
     Download: http://sourceforge.net/projects/libcds/files/
-    
+
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:
 
@@ -25,7 +25,7 @@
     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #ifndef CDSUNIT_MAP_TEST_FELDMAN_HASHMAP_H
@@ -52,7 +52,7 @@ namespace cds_test {
             // Precondition: map is empty
             // Postcondition: map is empty
 
-            ASSERT_TRUE( m.empty() );
+            ASSERT_TRUE( m.empty());
             ASSERT_CONTAINER_SIZE( m, 0 );
 
             typedef typename Map::value_type map_pair;
@@ -60,8 +60,8 @@ namespace cds_test {
 
             std::vector<key_type> arrKeys;
             for ( int i = 0; i < static_cast<int>(kkSize); ++i )
-                arrKeys.push_back( key_type( i ) );
-            shuffle( arrKeys.begin(), arrKeys.end() );
+                arrKeys.push_back( key_type( i ));
+            shuffle( arrKeys.begin(), arrKeys.end());
 
             std::vector< value_type > arrVals;
             for ( size_t i = 0; i < kkSize; ++i ) {
@@ -73,82 +73,82 @@ namespace cds_test {
 
             // insert/find
             for ( auto const& i : arrKeys ) {
-                value_type const& val( arrVals.at( i.nKey ) );
+                value_type const& val( arrVals.at( i.nKey ));
 
-                ASSERT_FALSE( m.contains( i.nKey ) );
-                ASSERT_FALSE( m.contains( i ) );
+                ASSERT_FALSE( m.contains( i.nKey ));
+                ASSERT_FALSE( m.contains( i ));
                 ASSERT_FALSE( m.find( i, []( map_pair const& ) {
                     ASSERT_TRUE( false );
-                } ) );
+                } ));
                 ASSERT_FALSE( m.find( i.nKey, []( map_pair const& ) {
                     EXPECT_TRUE( false );
-                } ) );
+                } ));
 
                 std::pair< bool, bool > updResult;
 
                 switch ( i.nKey % 16 ) {
                 case 0:
-                    ASSERT_TRUE( m.insert( i ) );
-                    ASSERT_FALSE( m.insert( i ) );
+                    ASSERT_TRUE( m.insert( i ));
+                    ASSERT_FALSE( m.insert( i ));
                     ASSERT_TRUE( m.find( i.nKey, []( map_pair& v ) {
                         v.second.nVal = v.first.nKey;
                         v.second.strVal = std::to_string( v.first.nKey );
-                    } ) );
+                    } ));
                     break;
                 case 1:
-                    ASSERT_TRUE( m.insert( i.nKey ) );
-                    ASSERT_FALSE( m.insert( i.nKey ) );
+                    ASSERT_TRUE( m.insert( i.nKey ));
+                    ASSERT_FALSE( m.insert( 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 );
-                    } ) );
+                    } ));
                     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 );
-                    } ) );
+                    } ));
                     break;
                 case 3:
-                    ASSERT_TRUE( m.insert( i, val ) );
-                    ASSERT_FALSE( m.insert( i, val ) );
+                    ASSERT_TRUE( m.insert( i, val ));
+                    ASSERT_FALSE( m.insert( i, val ));
                     break;
                 case 4:
-                    ASSERT_TRUE( m.insert( i.nKey, val.strVal ) );
-                    ASSERT_FALSE( m.insert( i.nKey, val.strVal ) );
+                    ASSERT_TRUE( m.insert( i.nKey, val.strVal ));
+                    ASSERT_FALSE( m.insert( i.nKey, val.strVal ));
                     break;
                 case 5:
-                    ASSERT_TRUE( m.insert( val.strVal, i.nKey ) );
-                    ASSERT_FALSE( m.insert( val.strVal, i.nKey ) );
+                    ASSERT_TRUE( m.insert( val.strVal, i.nKey ));
+                    ASSERT_FALSE( m.insert( val.strVal, i.nKey ));
                     break;
                 case 6:
                     ASSERT_TRUE( m.insert_with( i, []( map_pair& v ) {
                         v.second.nVal = v.first.nKey;
                         v.second.strVal = std::to_string( v.first.nKey );
-                    } ) );
-                    ASSERT_FALSE( m.insert_with( i, []( map_pair& v ) {
+                    } ));
+                    ASSERT_FALSE( m.insert_with( i, []( map_pair& ) {
                         EXPECT_TRUE( false );
-                    } ) );
+                    } ));
                     break;
                 case 7:
                     ASSERT_TRUE( m.insert_with( i.nKey, []( map_pair& v ) {
                         v.second.nVal = v.first.nKey;
                         v.second.strVal = std::to_string( v.first.nKey );
-                    } ) );
-                    ASSERT_FALSE( m.insert_with( i.nKey, []( map_pair& v ) {
+                    } ));
+                    ASSERT_FALSE( m.insert_with( i.nKey, []( map_pair& ) {
                         EXPECT_TRUE( false );
-                    } ) );
+                    } ));
                     break;
                 case 8:
                     ASSERT_TRUE( m.insert_with( val.strVal, []( map_pair& v ) {
                         v.second.nVal = v.first.nKey;
                         v.second.strVal = std::to_string( v.first.nKey );
-                    } ) );
-                    ASSERT_FALSE( m.insert_with( val.strVal, []( map_pair& v ) {
+                    } ));
+                    ASSERT_FALSE( m.insert_with( val.strVal, []( map_pair& ) {
                         EXPECT_TRUE( false );
-                    } ) );
+                    } ));
                     break;
                 case 9:
                     updResult = m.update( i.nKey, []( map_pair&, map_pair* ) {
@@ -220,56 +220,56 @@ namespace cds_test {
                     ASSERT_FALSE( updResult.second );
                     break;
                 case 12:
-                    ASSERT_TRUE( m.emplace( i.nKey ) );
-                    ASSERT_FALSE( m.emplace( i.nKey ) );
+                    ASSERT_TRUE( m.emplace( i.nKey ));
+                    ASSERT_FALSE( m.emplace( 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 );
-                    } ) );
+                    } ));
                     break;
                 case 13:
-                    ASSERT_TRUE( m.emplace( i, i.nKey ) );
-                    ASSERT_FALSE( m.emplace( i, i.nKey ) );
+                    ASSERT_TRUE( m.emplace( i, i.nKey ));
+                    ASSERT_FALSE( m.emplace( i, i.nKey ));
                     break;
                 case 14:
                 {
                     std::string str = val.strVal;
-                    ASSERT_TRUE( m.emplace( i, std::move( str ) ) );
-                    ASSERT_TRUE( str.empty() );
+                    ASSERT_TRUE( m.emplace( i, std::move( str )) );
+                    ASSERT_TRUE( str.empty());
                     str = val.strVal;
-                    ASSERT_FALSE( m.emplace( i, std::move( str ) ) );
-                    ASSERT_TRUE( str.empty() );
+                    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( str.empty() );
+                    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_TRUE( str.empty() );
+                    ASSERT_FALSE( m.emplace( i, i.nKey, std::move( str )) );
+                    ASSERT_TRUE( str.empty());
                 }
                 break;
                 }
 
-                ASSERT_TRUE( m.contains( i.nKey ) );
-                ASSERT_TRUE( m.contains( i ) );
+                ASSERT_TRUE( m.contains( i.nKey ));
+                ASSERT_TRUE( m.contains( i ));
                 ASSERT_TRUE( m.find( i, []( map_pair const& v ) {
                     EXPECT_EQ( v.first.nKey, v.second.nVal );
                     EXPECT_EQ( std::to_string( v.first.nKey ), v.second.strVal );
-                } ) );
+                } ));
                 ASSERT_TRUE( m.find( i.nKey, []( map_pair const& v ) {
                     EXPECT_EQ( v.first.nKey, v.second.nVal );
                     EXPECT_EQ( std::to_string( v.first.nKey ), v.second.strVal );
-                } ) );
+                } ));
             }
-            ASSERT_FALSE( m.empty() );
+            ASSERT_FALSE( m.empty());
             ASSERT_CONTAINER_SIZE( m, kkSize );
-            ASSERT_FALSE( m.begin() == m.end() );
-            ASSERT_FALSE( m.cbegin() == m.cend() );
+            ASSERT_FALSE( m.begin() == m.end());
+            ASSERT_FALSE( m.cbegin() == m.cend());
 
-            shuffle( arrKeys.begin(), arrKeys.end() );
+            shuffle( arrKeys.begin(), arrKeys.end());
 
             {
                 std::vector< typename Map::level_statistics > vect;
@@ -278,88 +278,88 @@ namespace cds_test {
 
             // erase/find
             for ( auto const& i : arrKeys ) {
-                value_type const& val( arrVals.at( i.nKey ) );
+                value_type const& val( arrVals.at( i.nKey ));
 
-                ASSERT_TRUE( m.contains( i.nKey ) );
-                ASSERT_TRUE( m.contains( val.strVal ) );
-                ASSERT_TRUE( m.contains( i ) );
+                ASSERT_TRUE( m.contains( i.nKey ));
+                ASSERT_TRUE( m.contains( val.strVal ));
+                ASSERT_TRUE( m.contains( i ));
                 ASSERT_TRUE( m.find( i, []( map_pair const& v ) {
                     EXPECT_EQ( v.first.nKey, v.second.nVal );
                     EXPECT_EQ( std::to_string( v.first.nKey ), v.second.strVal );
-                } ) );
+                } ));
                 ASSERT_TRUE( m.find( i.nKey, []( map_pair const& v ) {
                     EXPECT_EQ( v.first.nKey, v.second.nVal );
                     EXPECT_EQ( std::to_string( v.first.nKey ), v.second.strVal );
-                } ) );
+                } ));
 
                 switch ( i.nKey % 6 ) {
                 case 0:
-                    ASSERT_TRUE( m.erase( i ) );
-                    ASSERT_FALSE( m.erase( i ) );
+                    ASSERT_TRUE( m.erase( i ));
+                    ASSERT_FALSE( m.erase( i ));
                     break;
                 case 1:
-                    ASSERT_TRUE( m.erase( i.nKey ) );
-                    ASSERT_FALSE( m.erase( i.nKey ) );
+                    ASSERT_TRUE( m.erase( i.nKey ));
+                    ASSERT_FALSE( m.erase( i.nKey ));
                     break;
                 case 2:
-                    ASSERT_TRUE( m.erase( val.strVal ) );
-                    ASSERT_FALSE( m.erase( val.strVal ) );
+                    ASSERT_TRUE( m.erase( val.strVal ));
+                    ASSERT_FALSE( m.erase( val.strVal ));
                     break;
                 case 3:
                     ASSERT_TRUE( m.erase( i, []( map_pair& v ) {
                         EXPECT_EQ( v.first.nKey, v.second.nVal );
                         EXPECT_EQ( std::to_string( v.first.nKey ), v.second.strVal );
-                    } ) );
+                    } ));
                     ASSERT_FALSE( m.erase( i, []( map_pair& ) {
                         EXPECT_TRUE( false );
-                    } ) );
+                    } ));
                     break;
                 case 4:
                     ASSERT_TRUE( m.erase( i.nKey, []( map_pair& v ) {
                         EXPECT_EQ( v.first.nKey, v.second.nVal );
                         EXPECT_EQ( std::to_string( v.first.nKey ), v.second.strVal );
-                    } ) );
+                    } ));
                     ASSERT_FALSE( m.erase( i.nKey, []( map_pair& ) {
                         EXPECT_TRUE( false );
-                    } ) );
+                    } ));
                     break;
                 case 5:
                     ASSERT_TRUE( m.erase( val.strVal, []( map_pair& v ) {
                         EXPECT_EQ( v.first.nKey, v.second.nVal );
                         EXPECT_EQ( std::to_string( v.first.nKey ), v.second.strVal );
-                    } ) );
+                    } ));
                     ASSERT_FALSE( m.erase( val.strVal, []( map_pair& ) {
                         EXPECT_TRUE( false );
-                    } ) );
+                    } ));
                     break;
                 }
 
-                ASSERT_FALSE( m.contains( i.nKey ) );
-                ASSERT_FALSE( m.contains( i ) );
-                ASSERT_FALSE( m.contains( val.strVal ) );
+                ASSERT_FALSE( m.contains( i.nKey ));
+                ASSERT_FALSE( m.contains( i ));
+                ASSERT_FALSE( m.contains( val.strVal ));
                 ASSERT_FALSE( m.find( i, []( map_pair const& ) {
                     ASSERT_TRUE( false );
-                } ) );
+                } ));
                 ASSERT_FALSE( m.find( i.nKey, []( map_pair const& ) {
                     EXPECT_TRUE( false );
-                } ) );
+                } ));
             }
-            ASSERT_TRUE( m.empty() );
+            ASSERT_TRUE( m.empty());
             ASSERT_CONTAINER_SIZE( m, 0 );
 
-            ASSERT_TRUE( m.begin() == m.end() );
-            ASSERT_TRUE( m.cbegin() == m.cend() );
+            ASSERT_TRUE( m.begin() == m.end());
+            ASSERT_TRUE( m.cbegin() == m.cend());
 
             // clear
             for ( auto const& i : arrKeys )
-                ASSERT_TRUE( m.insert( i ) );
+                ASSERT_TRUE( m.insert( i ));
 
-            ASSERT_FALSE( m.empty() );
+            ASSERT_FALSE( m.empty());
             ASSERT_CONTAINER_SIZE( m, kkSize );
 
             m.clear();
 
-            ASSERT_TRUE( m.empty() );
+            ASSERT_TRUE( m.empty());
             ASSERT_CONTAINER_SIZE( m, 0 );
         }
     };
Unnamed repository; edit this file 'description' to name the repository.