projects / libcds.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Added MichaelMap<HP> based on IterableList
[libcds.git] / test / unit / map / test_map.h
diff --git a/test/unit/map/test_map.h b/test/unit/map/test_map.h
index 2c3912c213772e28601a9a5553cb8fec6abc7d28..5aee1d10ed2f78f08aa3e1ec03f8e7f2de9f475d 100644 (file)
--- a/test/unit/map/test_map.h
+++ b/test/unit/map/test_map.h
@@ -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_MAP_H
@@ -50,8 +50,8 @@ namespace cds_test {
             // Precondition: map is empty
             // Postcondition: map is empty
 
-            ASSERT_TRUE( m.empty());
-            ASSERT_CONTAINER_SIZE( m, 0 );
+            EXPECT_TRUE( m.empty());
+            EXPECT_CONTAINER_SIZE( m, 0 );
 
             typedef typename Map::value_type map_pair;
             size_t const kkSize = kSize;
@@ -73,16 +73,16 @@ namespace cds_test {
             for ( auto const& i : arrKeys ) {
                 value_type const& val( arrVals.at( i.nKey ));
 
-                ASSERT_FALSE( m.contains( i.nKey ));
-                ASSERT_FALSE( m.contains( i ));
-                ASSERT_FALSE( m.contains( other_item( i.nKey ), other_less()));
-                ASSERT_FALSE( m.find( i, []( map_pair const& ) {
-                    ASSERT_TRUE( false );
+                EXPECT_FALSE( m.contains( i.nKey ));
+                EXPECT_FALSE( m.contains( i ));
+                EXPECT_FALSE( m.contains( other_item( i.nKey ), other_less()));
+                EXPECT_FALSE( m.find( i, []( map_pair const& ) {
+                    EXPECT_TRUE( false );
                 } ));
-                ASSERT_FALSE( m.find( i.nKey, []( map_pair const& ) {
+                EXPECT_FALSE( m.find( i.nKey, []( map_pair const& ) {
                     EXPECT_TRUE( false );
                 } ));
-                ASSERT_FALSE( m.find_with( other_item( i.nKey ), other_less(), []( map_pair const& ) {
+                EXPECT_FALSE( m.find_with( other_item( i.nKey ), other_less(), []( map_pair const& ) {
                     EXPECT_TRUE( false );
                 } ));
 
@@ -90,65 +90,65 @@ namespace cds_test {
 
                 switch ( i.nKey % 16 ) {
                 case 0:
-                    ASSERT_TRUE( m.insert( i ));
-                    ASSERT_FALSE( m.insert( i ));
-                    ASSERT_TRUE( m.find( i.nKey, []( map_pair& v ) {
+                    EXPECT_TRUE( m.insert( i ));
+                    EXPECT_FALSE( m.insert( i ));
+                    EXPECT_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.find( i.nKey, []( map_pair& v ) {
+                    EXPECT_TRUE( m.insert( i.nKey ));
+                    EXPECT_FALSE( m.insert( i.nKey ));
+                    EXPECT_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.find( i.nKey, []( map_pair& v ) {
+                    EXPECT_TRUE( m.insert( std::to_string( i.nKey )));
+                    EXPECT_FALSE( m.insert( std::to_string( i.nKey )));
+                    EXPECT_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 ));
+                    EXPECT_TRUE( m.insert( i, val ));
+                    EXPECT_FALSE( m.insert( i, val ));
                     break;
                 case 4:
-                    ASSERT_TRUE( m.insert( i.nKey, val.strVal ));
-                    ASSERT_FALSE( m.insert( i.nKey, val.strVal ));
+                    EXPECT_TRUE( m.insert( i.nKey, val.strVal ));
+                    EXPECT_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 ));
+                    EXPECT_TRUE( m.insert( val.strVal, i.nKey ));
+                    EXPECT_FALSE( m.insert( val.strVal, i.nKey ));
                     break;
                 case 6:
-                    ASSERT_TRUE( m.insert_with( i, []( map_pair& v ) {
+                    EXPECT_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 ) {
+                    EXPECT_FALSE( m.insert_with( i, []( map_pair& v ) {
                         EXPECT_TRUE( false );
                     } ));
                     break;
                 case 7:
-                    ASSERT_TRUE( m.insert_with( i.nKey, []( map_pair& v ) {
+                    EXPECT_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 ) {
+                    EXPECT_FALSE( m.insert_with( i.nKey, []( map_pair& v ) {
                         EXPECT_TRUE( false );
                     } ));
                     break;
                 case 8:
-                    ASSERT_TRUE( m.insert_with( val.strVal, []( map_pair& v ) {
+                    EXPECT_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 ) {
+                    EXPECT_FALSE( m.insert_with( val.strVal, []( map_pair& v ) {
                         EXPECT_TRUE( false );
                     } ));
                     break;
@@ -156,122 +156,122 @@ namespace cds_test {
                     updResult = m.update( i.nKey, []( bool, map_pair& ) {
                         EXPECT_TRUE( false );
                     }, false );
-                    ASSERT_FALSE( updResult.first );
-                    ASSERT_FALSE( updResult.second );
+                    EXPECT_FALSE( updResult.first );
+                    EXPECT_FALSE( updResult.second );
 
                     updResult = m.update( i.nKey, []( bool bNew, map_pair& v ) {
                         EXPECT_TRUE( bNew );
                         v.second.nVal = v.first.nKey;
                     });
-                    ASSERT_TRUE( updResult.first );
-                    ASSERT_TRUE( updResult.second );
+                    EXPECT_TRUE( updResult.first );
+                    EXPECT_TRUE( updResult.second );
 
                     updResult = m.update( i.nKey, []( bool bNew, map_pair& v ) {
                         EXPECT_FALSE( bNew );
                         EXPECT_EQ( v.first.nKey, v.second.nVal );
                         v.second.strVal = std::to_string( v.second.nVal );
                     } );
-                    ASSERT_TRUE( updResult.first );
-                    ASSERT_FALSE( updResult.second );
+                    EXPECT_TRUE( updResult.first );
+                    EXPECT_FALSE( updResult.second );
                     break;
                 case 10:
                     updResult = m.update( i, []( bool, map_pair& ) {
                         EXPECT_TRUE( false );
                     }, false );
-                    ASSERT_FALSE( updResult.first );
-                    ASSERT_FALSE( updResult.second );
+                    EXPECT_FALSE( updResult.first );
+                    EXPECT_FALSE( updResult.second );
 
                     updResult = m.update( i, []( bool bNew, map_pair& v ) {
                         EXPECT_TRUE( bNew );
                         v.second.nVal = v.first.nKey;
                     });
-                    ASSERT_TRUE( updResult.first );
-                    ASSERT_TRUE( updResult.second );
+                    EXPECT_TRUE( updResult.first );
+                    EXPECT_TRUE( updResult.second );
 
                     updResult = m.update( i, []( bool bNew, map_pair& v ) {
                         EXPECT_FALSE( bNew );
                         EXPECT_EQ( v.first.nKey, v.second.nVal );
                         v.second.strVal = std::to_string( v.second.nVal );
                     } );
-                    ASSERT_TRUE( updResult.first );
-                    ASSERT_FALSE( updResult.second );
+                    EXPECT_TRUE( updResult.first );
+                    EXPECT_FALSE( updResult.second );
                     break;
                 case 11:
                     updResult = m.update( val.strVal, []( bool, map_pair& ) {
                         EXPECT_TRUE( false );
                     }, false );
-                    ASSERT_FALSE( updResult.first );
-                    ASSERT_FALSE( updResult.second );
+                    EXPECT_FALSE( updResult.first );
+                    EXPECT_FALSE( updResult.second );
 
                     updResult = m.update( val.strVal, []( bool bNew, map_pair& v ) {
                         EXPECT_TRUE( bNew );
                         v.second.nVal = v.first.nKey;
                     });
-                    ASSERT_TRUE( updResult.first );
-                    ASSERT_TRUE( updResult.second );
+                    EXPECT_TRUE( updResult.first );
+                    EXPECT_TRUE( updResult.second );
 
                     updResult = m.update( val.strVal, []( bool bNew, map_pair& v ) {
                         EXPECT_FALSE( bNew );
                         EXPECT_EQ( v.first.nKey, v.second.nVal );
                         v.second.strVal = std::to_string( v.second.nVal );
                     } );
-                    ASSERT_TRUE( updResult.first );
-                    ASSERT_FALSE( updResult.second );
+                    EXPECT_TRUE( updResult.first );
+                    EXPECT_FALSE( updResult.second );
                     break;
                 case 12:
-                    ASSERT_TRUE( m.emplace( i.nKey ));
-                    ASSERT_FALSE( m.emplace( i.nKey ));
-                    ASSERT_TRUE( m.find( i.nKey, []( map_pair& v ) {
+                    EXPECT_TRUE( m.emplace( i.nKey ));
+                    EXPECT_FALSE( m.emplace( i.nKey ));
+                    EXPECT_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 ));
+                    EXPECT_TRUE( m.emplace( i, i.nKey ));
+                    EXPECT_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());
+                        EXPECT_TRUE( m.emplace( i, std::move( str )));
+                        EXPECT_TRUE( str.empty());
                         str = val.strVal;
-                        ASSERT_FALSE( m.emplace( i, std::move( str )));
-                        ASSERT_TRUE( str.empty());
+                        EXPECT_FALSE( m.emplace( i, std::move( str )));
+                        EXPECT_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());
+                        EXPECT_TRUE( m.emplace( i, i.nKey, std::move( str )));
+                        EXPECT_TRUE( str.empty());
                         str = val.strVal;
-                        ASSERT_FALSE( m.emplace( i, i.nKey, std::move( str )));
-                        ASSERT_TRUE( str.empty());
+                        EXPECT_FALSE( m.emplace( i, i.nKey, std::move( str )));
+                        EXPECT_TRUE( str.empty());
                     }
                     break;
                 }
 
-                ASSERT_TRUE( m.contains( i.nKey ));
-                ASSERT_TRUE( m.contains( i ));
-                ASSERT_TRUE( m.contains( other_item( i.nKey ), other_less()));
-                ASSERT_TRUE( m.find( i, []( map_pair const& v ) {
+                EXPECT_TRUE( m.contains( i.nKey ));
+                EXPECT_TRUE( m.contains( i ));
+                EXPECT_TRUE( m.contains( other_item( i.nKey ), other_less()));
+                EXPECT_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_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_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( map_pair const& v ) {
+                EXPECT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( 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_CONTAINER_SIZE( m, kkSize );
-            ASSERT_FALSE( m.begin() == m.end() );
-            ASSERT_FALSE( m.cbegin() == m.cend() );
+            EXPECT_FALSE( m.empty() );
+            EXPECT_CONTAINER_SIZE( m, kkSize );
+            EXPECT_FALSE( m.begin() == m.end() );
+            EXPECT_FALSE( m.cbegin() == m.cend() );
 
             shuffle( arrKeys.begin(), arrKeys.end() );
 
@@ -279,19 +279,19 @@ namespace cds_test {
             for ( auto const& i : arrKeys ) {
                 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( other_item( i.nKey ), other_less()));
-                ASSERT_TRUE( m.find( i, []( map_pair const& v ) {
+                EXPECT_TRUE( m.contains( i.nKey ));
+                EXPECT_TRUE( m.contains( val.strVal ) );
+                EXPECT_TRUE( m.contains( i ));
+                EXPECT_TRUE( m.contains( other_item( i.nKey ), other_less()));
+                EXPECT_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_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_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( map_pair const& v ) {
+                EXPECT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( map_pair const& v ) {
                     EXPECT_EQ( v.first.nKey, v.second.nVal );
                     EXPECT_EQ( std::to_string( v.first.nKey ), v.second.strVal );
                 } ));
@@ -299,90 +299,90 @@ namespace cds_test {
 
                 switch ( i.nKey % 8 ) {
                 case 0:
-                    ASSERT_TRUE( m.erase( i ));
-                    ASSERT_FALSE( m.erase( i ));
+                    EXPECT_TRUE( m.erase( i ));
+                    EXPECT_FALSE( m.erase( i ));
                     break;
                 case 1:
-                    ASSERT_TRUE( m.erase( i.nKey ));
-                    ASSERT_FALSE( m.erase( i.nKey ));
+                    EXPECT_TRUE( m.erase( i.nKey ));
+                    EXPECT_FALSE( m.erase( i.nKey ));
                     break;
                 case 2:
-                    ASSERT_TRUE( m.erase( val.strVal ));
-                    ASSERT_FALSE( m.erase( val.strVal ));
+                    EXPECT_TRUE( m.erase( val.strVal ));
+                    EXPECT_FALSE( m.erase( val.strVal ));
                     break;
                 case 3:
-                    ASSERT_TRUE( m.erase_with( other_item( i.nKey ), other_less()));
-                    ASSERT_FALSE( m.erase_with( other_item( i.nKey ), other_less()));
+                    EXPECT_TRUE( m.erase_with( other_item( i.nKey ), other_less()));
+                    EXPECT_FALSE( m.erase_with( other_item( i.nKey ), other_less()));
                     break;
                 case 4:
-                    ASSERT_TRUE( m.erase( i, []( map_pair& v ) {
+                    EXPECT_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_FALSE( m.erase( i, []( map_pair& ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 5:
-                    ASSERT_TRUE( m.erase( i.nKey, []( map_pair& v ) {
+                    EXPECT_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_FALSE( m.erase( i.nKey, []( map_pair& ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 6:
-                    ASSERT_TRUE( m.erase( val.strVal, []( map_pair& v ) {
+                    EXPECT_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_FALSE( m.erase( val.strVal, []( map_pair& ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 7:
-                    ASSERT_TRUE( m.erase_with( other_item( i.nKey ), other_less(), []( map_pair& v ) {
+                    EXPECT_TRUE( m.erase_with( other_item( i.nKey ), other_less(), []( 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_with( other_item( i.nKey ), other_less(), []( map_pair& ) {
+                    EXPECT_FALSE( m.erase_with( other_item( i.nKey ), other_less(), []( 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( other_item( i.nKey ), other_less()));
-                ASSERT_FALSE( m.find( i, []( map_pair const& ) {
-                    ASSERT_TRUE( false );
+                EXPECT_FALSE( m.contains( i.nKey ));
+                EXPECT_FALSE( m.contains( i ));
+                EXPECT_FALSE( m.contains( val.strVal ));
+                EXPECT_FALSE( m.contains( other_item( i.nKey ), other_less()));
+                EXPECT_FALSE( m.find( i, []( map_pair const& ) {
+                    EXPECT_TRUE( false );
                 } ));
-                ASSERT_FALSE( m.find( i.nKey, []( map_pair const& ) {
+                EXPECT_FALSE( m.find( i.nKey, []( map_pair const& ) {
                     EXPECT_TRUE( false );
                 } ));
-                ASSERT_FALSE( m.find_with( other_item( i.nKey ), other_less(), []( map_pair const& ) {
+                EXPECT_FALSE( m.find_with( other_item( i.nKey ), other_less(), []( map_pair const& ) {
                     EXPECT_TRUE( false );
                 } ));
             }
-            ASSERT_TRUE( m.empty() );
-            ASSERT_CONTAINER_SIZE( m, 0 );
+            EXPECT_TRUE( m.empty() );
+            EXPECT_CONTAINER_SIZE( m, 0 );
 
-            ASSERT_TRUE( m.begin() == m.end());
-            ASSERT_TRUE( m.cbegin() == m.cend());
+            EXPECT_TRUE( m.begin() == m.end());
+            EXPECT_TRUE( m.cbegin() == m.cend());
 
             // clear
             for ( auto const& i : arrKeys )
-                ASSERT_TRUE( m.insert( i ));
+                EXPECT_TRUE( m.insert( i ));
 
-            ASSERT_FALSE( m.empty() );
-            ASSERT_CONTAINER_SIZE( m, kkSize );
+            EXPECT_FALSE( m.empty() );
+            EXPECT_CONTAINER_SIZE( m, kkSize );
 
             m.clear();
 
-            ASSERT_TRUE( m.empty() );
-            ASSERT_CONTAINER_SIZE( m, 0 );
+            EXPECT_TRUE( m.empty() );
+            EXPECT_CONTAINER_SIZE( m, 0 );
         }
     };
 
Unnamed repository; edit this file 'description' to name the repository.