Removed deprecated functions ensure() and find(key) from set unit tests

diff --git a/tests/test-hdr/set/hdr_intrusive_set.h b/tests/test-hdr/set/hdr_intrusive_set.h
index fc3c48bcf9f1068ca05286e5ee2e31c557df7a7e..4a047e3c4d0be9a826308888efbdcff4a8b3d48b 100644 (file)
--- a/tests/test-hdr/set/hdr_intrusive_set.h
+++ b/tests/test-hdr/set/hdr_intrusive_set.h
@@ -25,8 +25,8 @@ namespace set {
         {
             unsigned int nDisposeCount  ;   // count of disposer calling
             unsigned int nFindCount     ;   // count of find-functor calling
-            unsigned int nEnsureNewCount;
-            unsigned int nEnsureCount;
+            unsigned int nUpdateNewCount;
+            unsigned int nUpdateCount;
             mutable unsigned int nEraseCount;
 
             stat()
@@ -211,15 +211,15 @@ namespace set {
             }
         };
 
-        struct ensure_functor
+        struct update_functor
         {
             template <typename Item>
             void operator()( bool bNew, Item& item, Item& /*val*/ )
             {
                 if ( bNew )
-                    ++item.nEnsureNewCount;
+                    ++item.nUpdateNewCount;
                 else
-                    ++item.nEnsureCount;
+                    ++item.nUpdateCount;
             }
         };
 
@@ -246,13 +246,13 @@ namespace set {
             CPPUNIT_ASSERT( check_size( s, 0 ));
 
             // insert/find test
-            CPPUNIT_ASSERT( !s.find( v1.key() ));
+            CPPUNIT_ASSERT( !s.contains( v1.key() ));
             CPPUNIT_ASSERT( s.insert( v1 ));
-            CPPUNIT_ASSERT( s.find( v1.key() ));
+            CPPUNIT_ASSERT( s.contains( v1.key() ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
-            CPPUNIT_ASSERT( !s.find_with( v2.key(), less<value_type>() ));
+            CPPUNIT_ASSERT( !s.contains( v2.key(), less<value_type>() ));
             CPPUNIT_ASSERT( s.insert( v2 ));
             CPPUNIT_ASSERT( v2.nFindCount == 0 );
             CPPUNIT_ASSERT( s.find_with( key = v2.key(), less<value_type>(), find_functor() ));
@@ -264,7 +264,7 @@ namespace set {
             {
                 insert_functor  fi;
                 find_functor    ff;
-                CPPUNIT_ASSERT( !s.find( v3 ));
+                CPPUNIT_ASSERT( !s.contains( v3 ));
                 CPPUNIT_ASSERT( v3.nVal != v3.nKey * 100 );
                 CPPUNIT_ASSERT( s.insert( v3, std::ref(fi) ));
                 CPPUNIT_ASSERT( v3.nVal == v3.nKey * 100 );
@@ -278,25 +278,25 @@ namespace set {
 
             // unlink test
             CPPUNIT_ASSERT( s.unlink( v1 ));
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( s.find( v2 ));
-            CPPUNIT_ASSERT( s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( s.contains( v2 ));
+            CPPUNIT_ASSERT( s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 2 ));
 
             CPPUNIT_ASSERT( !s.unlink( v1 ));
-            CPPUNIT_ASSERT( !s.find( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
             CPPUNIT_ASSERT( check_size( s, 2 ));
 
-            CPPUNIT_ASSERT( s.find_with( v3, less<value_type>() ));
+            CPPUNIT_ASSERT( s.contains( v3, less<value_type>() ));
             CPPUNIT_ASSERT( s.unlink( v3 ));
-            CPPUNIT_ASSERT( !s.find_with( v3, less<value_type>() ));
+            CPPUNIT_ASSERT( !s.contains( v3, less<value_type>() ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
 
-            CPPUNIT_ASSERT( s.find( v2 ));
+            CPPUNIT_ASSERT( s.contains( v2 ));
             CPPUNIT_ASSERT( s.unlink( v2 ));
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( !s.find( v2 ));
-            CPPUNIT_ASSERT( !s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v2 ));
+            CPPUNIT_ASSERT( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 0 ));
             CPPUNIT_ASSERT( s.empty() );
 
@@ -306,103 +306,117 @@ namespace set {
             CPPUNIT_ASSERT( v2.nDisposeCount == 1 );
             CPPUNIT_ASSERT( v3.nDisposeCount == 1 );
 
-            // ensure test
+            // update test
             {
-                ensure_functor f;
-                std::pair<bool, bool> ret = s.ensure( v1, f );
+                update_functor f;
+                std::pair<bool, bool> ret = s.update(v1, f, false);
+                CPPUNIT_ASSERT(!ret.first);
+                CPPUNIT_ASSERT(!ret.second);
+                CPPUNIT_ASSERT(v1.nUpdateNewCount == 0);
+                CPPUNIT_ASSERT(v1.nUpdateCount == 0);
+                CPPUNIT_ASSERT(check_size(s, 0));
+
+                ret = s.update( v1, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( ret.second );
-                CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
+                CPPUNIT_ASSERT( v1.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v1.nUpdateCount == 0 );
                 CPPUNIT_ASSERT( check_size( s, 1 ));
 
-                ret = s.ensure( v2, f );
+                ret = s.update(v1, f, false);
+                CPPUNIT_ASSERT(ret.first);
+                CPPUNIT_ASSERT(!ret.second);
+                CPPUNIT_ASSERT(v1.nUpdateNewCount == 1);
+                CPPUNIT_ASSERT(v1.nUpdateCount == 1);
+                CPPUNIT_ASSERT(check_size(s, 1));
+
+                ret = s.update( v2, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( ret.second );
-                CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
+                CPPUNIT_ASSERT( v2.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v2.nUpdateCount == 0 );
                 CPPUNIT_ASSERT( check_size( s, 2 ));
 
-                ret = s.ensure( v3, f );
+                ret = s.update( v3, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( ret.second );
-                CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
+                CPPUNIT_ASSERT( v3.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v3.nUpdateCount == 0 );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                CPPUNIT_ASSERT( s.find( v1 ));
-                CPPUNIT_ASSERT( s.find( v2 ));
-                CPPUNIT_ASSERT( s.find( v3 ));
+                CPPUNIT_ASSERT( s.contains( v1 ));
+                CPPUNIT_ASSERT( s.contains( v2 ));
+                CPPUNIT_ASSERT( s.contains( v3 ));
 
-                ret = s.ensure( v1, f );
+                ret = s.update( v1, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( !ret.second );
-                CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
+                CPPUNIT_ASSERT( v1.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v1.nUpdateCount == 1 );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                ret = s.ensure( v2, f );
+                ret = s.update( v2, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( !ret.second );
-                CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
+                CPPUNIT_ASSERT( v2.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v2.nUpdateCount == 1 );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                ret = s.ensure( v3, f );
+                ret = s.update( v3, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( !ret.second );
-                CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
+                CPPUNIT_ASSERT( v3.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v3.nUpdateCount == 1 );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                CPPUNIT_ASSERT( s.find( v1 ));
-                CPPUNIT_ASSERT( s.find( v2 ));
-                CPPUNIT_ASSERT( s.find( v3 ));
+                CPPUNIT_ASSERT( s.contains( v1 ));
+                CPPUNIT_ASSERT( s.contains( v2 ));
+                CPPUNIT_ASSERT( s.contains( v3 ));
             }
 
             // erase test
-            CPPUNIT_ASSERT( s.find( v1 ));
-            CPPUNIT_ASSERT( s.find_with( v2, less<value_type>() ));
-            CPPUNIT_ASSERT( s.find( v3 ));
+            CPPUNIT_ASSERT( s.contains( v1 ));
+            CPPUNIT_ASSERT( s.contains( v2, less<value_type>() ));
+            CPPUNIT_ASSERT( s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 3 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( s.erase( v1 ));
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( s.find( v2 ));
-            CPPUNIT_ASSERT( s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( s.contains( v2 ));
+            CPPUNIT_ASSERT( s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 2 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( v1.nEraseCount == 0 );
             CPPUNIT_ASSERT( !s.erase( v1, erase_functor() ));
             CPPUNIT_ASSERT( v1.nEraseCount == 0 );
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( s.find( v2 ));
-            CPPUNIT_ASSERT( s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( s.contains( v2 ));
+            CPPUNIT_ASSERT( s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 2 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( v2.nEraseCount == 0 );
             CPPUNIT_ASSERT( s.erase_with( v2.key(), less<value_type>(), erase_functor() ));
             CPPUNIT_ASSERT( v2.nEraseCount == 1 );
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( !s.find( v2 ));
-            CPPUNIT_ASSERT( s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v2 ));
+            CPPUNIT_ASSERT( s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( !s.erase( v2.key() ));
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( !s.find( v2 ));
-            CPPUNIT_ASSERT( s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v2 ));
+            CPPUNIT_ASSERT( s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( s.erase( v3 ));
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( !s.find( v2 ));
-            CPPUNIT_ASSERT( !s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v2 ));
+            CPPUNIT_ASSERT( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 0 ));
             CPPUNIT_ASSERT( s.empty() );
 
@@ -424,30 +438,30 @@ namespace set {
             }
 
             CPPUNIT_ASSERT( s.unlink( v3 ) );
-            CPPUNIT_ASSERT( s.find( v1 ));
-            CPPUNIT_ASSERT( !s.find( v2 ));
-            CPPUNIT_ASSERT( !s.find( v3 ));
+            CPPUNIT_ASSERT( s.contains( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v2 ));
+            CPPUNIT_ASSERT( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( !s.unlink( v3 ));
-            CPPUNIT_ASSERT( s.find( v1 ));
-            CPPUNIT_ASSERT( !s.find( v2 ));
-            CPPUNIT_ASSERT( !s.find( v3 ));
+            CPPUNIT_ASSERT( s.contains( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v2 ));
+            CPPUNIT_ASSERT( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( s.unlink( v1 ));
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( !s.find( v2 ));
-            CPPUNIT_ASSERT( !s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v2 ));
+            CPPUNIT_ASSERT( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 0 ));
             CPPUNIT_ASSERT( s.empty() );
 
             CPPUNIT_ASSERT( !s.unlink( v2 ));
-            CPPUNIT_ASSERT( !s.find( v1 ));
-            CPPUNIT_ASSERT( !s.find( v2 ));
-            CPPUNIT_ASSERT( !s.find( v3 ));
+            CPPUNIT_ASSERT( !s.contains( v1 ));
+            CPPUNIT_ASSERT( !s.contains( v2 ));
+            CPPUNIT_ASSERT( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 0 ));
             CPPUNIT_ASSERT( s.empty() );
 
@@ -646,13 +660,13 @@ namespace set {
                     CPPUNIT_ASSERT( check_size( s, 0 ));
 
                     // insert/find test
-                    CPPUNIT_ASSERT( s.find( v1.key() ) == nullptr );
+                    CPPUNIT_ASSERT( s.contains( v1.key() ) == nullptr );
                     CPPUNIT_ASSERT( s.insert( v1 ));
-                    CPPUNIT_ASSERT( s.find_with( v1.key(), less<value_type>() ) == &v1 );
+                    CPPUNIT_ASSERT( s.contains( v1.key(), less<value_type>() ) == &v1 );
                     CPPUNIT_ASSERT( check_size( s, 1 ));
                     CPPUNIT_ASSERT( !s.empty() );
 
-                    CPPUNIT_ASSERT( s.find( v2.key() ) == nullptr );
+                    CPPUNIT_ASSERT( s.contains( v2.key() ) == nullptr );
                     CPPUNIT_ASSERT( s.insert( v2 ));
                     CPPUNIT_ASSERT( v2.nFindCount == 0 );
                     CPPUNIT_ASSERT( s.find( key = v2.key(), find_functor() ));
@@ -663,7 +677,7 @@ namespace set {
 
                     {
                         find_functor    ff;
-                        CPPUNIT_ASSERT( s.find( v3 ) == nullptr );
+                        CPPUNIT_ASSERT( s.contains( v3 ) == nullptr );
                         CPPUNIT_ASSERT( s.insert( v3 ));
                         CPPUNIT_ASSERT( v3.nFindCount == 0 );
                         CPPUNIT_ASSERT( s.find_with( v3, less<value_type>(), std::ref(ff) ));
@@ -680,60 +694,75 @@ namespace set {
                 CPPUNIT_ASSERT( v3.nDisposeCount == 1 );
 
 
-                // ensure test
+                // update test
                 {
                     Set s( 64, 4 );
 
-                    ensure_functor f;
-                    std::pair<bool, bool> ret = s.ensure( v1, f );
+                    update_functor f;
+
+                    std::pair<bool, bool> ret = s.update(v1, f, false);
+                    CPPUNIT_ASSERT(!ret.first);
+                    CPPUNIT_ASSERT(!ret.second);
+                    CPPUNIT_ASSERT(v1.nUpdateNewCount == 0);
+                    CPPUNIT_ASSERT(v1.nUpdateCount == 0);
+                    CPPUNIT_ASSERT(check_size(s, 0));
+
+                    ret = s.update( v1, f );
                     CPPUNIT_ASSERT( ret.first );
                     CPPUNIT_ASSERT( ret.second );
-                    CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
-                    CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
+                    CPPUNIT_ASSERT( v1.nUpdateNewCount == 1 );
+                    CPPUNIT_ASSERT( v1.nUpdateCount == 0 );
                     CPPUNIT_ASSERT( check_size( s, 1 ));
 
-                    ret = s.ensure( v2, f );
+                    ret = s.update(v1, f, false);
+                    CPPUNIT_ASSERT(ret.first);
+                    CPPUNIT_ASSERT(!ret.second);
+                    CPPUNIT_ASSERT(v1.nUpdateNewCount == 1);
+                    CPPUNIT_ASSERT(v1.nUpdateCount == 1);
+                    CPPUNIT_ASSERT(check_size(s, 1));
+
+                    ret = s.update( v2, f );
                     CPPUNIT_ASSERT( ret.first );
                     CPPUNIT_ASSERT( ret.second );
-                    CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
-                    CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
+                    CPPUNIT_ASSERT( v2.nUpdateNewCount == 1 );
+                    CPPUNIT_ASSERT( v2.nUpdateCount == 0 );
                     CPPUNIT_ASSERT( check_size( s, 2 ));
 
-                    ret = s.ensure( v3, f );
+                    ret = s.update( v3, f );
                     CPPUNIT_ASSERT( ret.first );
                     CPPUNIT_ASSERT( ret.second );
-                    CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
-                    CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
+                    CPPUNIT_ASSERT( v3.nUpdateNewCount == 1 );
+                    CPPUNIT_ASSERT( v3.nUpdateCount == 0 );
                     CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                    CPPUNIT_ASSERT( s.find( v1 ) == &v1 );
-                    CPPUNIT_ASSERT( s.find( v2 ) == &v2 );
-                    CPPUNIT_ASSERT( s.find( v3 ) == &v3 );
+                    CPPUNIT_ASSERT( s.contains( v1 ) == &v1 );
+                    CPPUNIT_ASSERT( s.contains( v2 ) == &v2 );
+                    CPPUNIT_ASSERT( s.contains( v3 ) == &v3 );
 
-                    ret = s.ensure( v1, f );
+                    ret = s.update( v1, f );
                     CPPUNIT_ASSERT( ret.first );
                     CPPUNIT_ASSERT( !ret.second );
-                    CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
-                    CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
+                    CPPUNIT_ASSERT( v1.nUpdateNewCount == 1 );
+                    CPPUNIT_ASSERT( v1.nUpdateCount == 1 );
                     CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                    ret = s.ensure( v2, f );
+                    ret = s.update( v2, f );
                     CPPUNIT_ASSERT( ret.first );
                     CPPUNIT_ASSERT( !ret.second );
-                    CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
-                    CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
+                    CPPUNIT_ASSERT( v2.nUpdateNewCount == 1 );
+                    CPPUNIT_ASSERT( v2.nUpdateCount == 1 );
                     CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                    ret = s.ensure( v3, f );
+                    ret = s.update( v3, f );
                     CPPUNIT_ASSERT( ret.first );
                     CPPUNIT_ASSERT( !ret.second );
-                    CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
-                    CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
+                    CPPUNIT_ASSERT( v3.nUpdateNewCount == 1 );
+                    CPPUNIT_ASSERT( v3.nUpdateCount == 1 );
                     CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                    CPPUNIT_ASSERT( s.find( v1 ) == &v1 );
-                    CPPUNIT_ASSERT( s.find( v2 ) == &v2 );
-                    CPPUNIT_ASSERT( s.find( v3 ) == &v3 );
+                    CPPUNIT_ASSERT( s.contains( v1 ) == &v1 );
+                    CPPUNIT_ASSERT( s.contains( v2 ) == &v2 );
+                    CPPUNIT_ASSERT( s.contains( v3 ) == &v3 );
                 }
             }
 
@@ -765,13 +794,13 @@ namespace set {
 
             // insert/find test
 
-            ASSERT_RCU_FIND( !s.find_with( v1.key(), less<value_type>() ));
+            ASSERT_RCU_FIND( !s.contains( v1.key(), less<value_type>() ));
             CPPUNIT_ASSERT( s.insert( v1 ));
-            ASSERT_RCU_FIND( s.find_with( v1.key(), less<value_type>()) );
+            ASSERT_RCU_FIND( s.contains( v1.key(), less<value_type>()) );
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
-            ASSERT_RCU_FIND( !s.find( v2.key() ));
+            ASSERT_RCU_FIND( !s.contains( v2.key() ));
             CPPUNIT_ASSERT( s.insert( v2 ));
             CPPUNIT_ASSERT( v2.nFindCount == 0 );
             CPPUNIT_ASSERT( s.find( key = v2.key(), find_functor() ));
@@ -783,7 +812,7 @@ namespace set {
             {
                 insert_functor  fi;
                 find_functor    ff;
-                ASSERT_RCU_FIND( !s.find( v3 ));
+                ASSERT_RCU_FIND( !s.contains( v3 ));
                 CPPUNIT_ASSERT( v3.nVal != v3.nKey * 100 );
                 CPPUNIT_ASSERT( s.insert( v3, std::ref(fi) ));
                 CPPUNIT_ASSERT( v3.nVal == v3.nKey * 100 );
@@ -797,25 +826,25 @@ namespace set {
 
             // unlink test
             CPPUNIT_ASSERT( s.unlink( v1 ));
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( s.find( v2 ));
-            ASSERT_RCU_FIND( s.find( v3 ));
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( s.contains( v2 ));
+            ASSERT_RCU_FIND( s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 2 ));
 
             CPPUNIT_ASSERT( !s.unlink( v1 ));
-            ASSERT_RCU_FIND( !s.find( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v1 ));
             CPPUNIT_ASSERT( check_size( s, 2 ));
 
-            ASSERT_RCU_FIND( s.find( v3 ) );
+            ASSERT_RCU_FIND( s.contains( v3 ) );
             CPPUNIT_ASSERT( s.unlink( v3 ));
-            ASSERT_RCU_FIND( !s.find( v3 ));
+            ASSERT_RCU_FIND( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
 
-            ASSERT_RCU_FIND( s.find( v2 ));
+            ASSERT_RCU_FIND( s.contains( v2 ));
             CPPUNIT_ASSERT( s.unlink( v2 ));
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( !s.find( v2 ));
-            ASSERT_RCU_FIND( !s.find( v3 ));
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v2 ));
+            ASSERT_RCU_FIND( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 0 ));
             CPPUNIT_ASSERT( s.empty() );
 
@@ -825,109 +854,124 @@ namespace set {
             CPPUNIT_ASSERT( v2.nDisposeCount == 1 );
             CPPUNIT_ASSERT( v3.nDisposeCount == 1 );
 
-            // ensure test
+            // update test
             {
-                ensure_functor f;
-                std::pair<bool, bool> ret = s.ensure( v1, f );
+                update_functor f;
+
+                std::pair<bool, bool> ret = s.update(v1, f, false);
+                CPPUNIT_ASSERT(!ret.first);
+                CPPUNIT_ASSERT(!ret.second);
+                CPPUNIT_ASSERT(v1.nUpdateNewCount == 0);
+                CPPUNIT_ASSERT(v1.nUpdateCount == 0);
+                CPPUNIT_ASSERT(check_size(s, 0));
+
+                ret = s.update( v1, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( ret.second );
-                CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
+                CPPUNIT_ASSERT( v1.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v1.nUpdateCount == 0 );
                 CPPUNIT_ASSERT( check_size( s, 1 ));
 
-                ret = s.ensure( v2, f );
+                ret = s.update(v1, f, false);
+                CPPUNIT_ASSERT(ret.first);
+                CPPUNIT_ASSERT(!ret.second);
+                CPPUNIT_ASSERT(v1.nUpdateNewCount == 1);
+                CPPUNIT_ASSERT(v1.nUpdateCount == 1);
+                CPPUNIT_ASSERT(check_size(s, 1));
+
+                ret = s.update( v2, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( ret.second );
-                CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
+                CPPUNIT_ASSERT( v2.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v2.nUpdateCount == 0 );
                 CPPUNIT_ASSERT( check_size( s, 2 ));
 
-                ret = s.ensure( v3, f );
+                ret = s.update( v3, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( ret.second );
-                CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
+                CPPUNIT_ASSERT( v3.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v3.nUpdateCount == 0 );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                ASSERT_RCU_FIND( s.find( v1 ));
-                ASSERT_RCU_FIND( s.find( v2 ));
-                ASSERT_RCU_FIND( s.find( v3 ));
+                ASSERT_RCU_FIND( s.contains( v1 ));
+                ASSERT_RCU_FIND( s.contains( v2 ));
+                ASSERT_RCU_FIND( s.contains( v3 ));
 
-                ret = s.ensure( v1, f );
+                ret = s.update( v1, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( !ret.second );
-                CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
+                CPPUNIT_ASSERT( v1.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v1.nUpdateCount == 1 );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                ret = s.ensure( v2, f );
+                ret = s.update( v2, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( !ret.second );
-                CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
+                CPPUNIT_ASSERT( v2.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v2.nUpdateCount == 1 );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                ret = s.ensure( v3, f );
+                ret = s.update( v3, f );
                 CPPUNIT_ASSERT( ret.first );
                 CPPUNIT_ASSERT( !ret.second );
-                CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
-                CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
+                CPPUNIT_ASSERT( v3.nUpdateNewCount == 1 );
+                CPPUNIT_ASSERT( v3.nUpdateCount == 1 );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                ASSERT_RCU_FIND( s.find( v1 ) );
-                ASSERT_RCU_FIND( s.find( v2 ));
-                ASSERT_RCU_FIND( s.find( v3 ));
+                ASSERT_RCU_FIND( s.contains( v1 ) );
+                ASSERT_RCU_FIND( s.contains( v2 ));
+                ASSERT_RCU_FIND( s.contains( v3 ));
             }
 
             // erase test
-            ASSERT_RCU_FIND( s.find( v1 ));
-            ASSERT_RCU_FIND( s.find_with( v2, less<value_type>() ));
-            ASSERT_RCU_FIND( s.find( v3 ));
+            ASSERT_RCU_FIND( s.contains( v1 ));
+            ASSERT_RCU_FIND( s.contains( v2, less<value_type>() ));
+            ASSERT_RCU_FIND( s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 3 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( v1.nEraseCount == 0 );
             CPPUNIT_ASSERT( s.erase_with( v1, less<value_type>(), erase_functor() ));
             CPPUNIT_ASSERT( v1.nEraseCount == 1 );
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( s.find( v2 ) );
-            ASSERT_RCU_FIND( s.find( v3 ) );
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( s.contains( v2 ) );
+            ASSERT_RCU_FIND( s.contains( v3 ) );
             CPPUNIT_ASSERT( check_size( s, 2 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( !s.erase( v1 ));
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( s.find( v2 ));
-            ASSERT_RCU_FIND( s.find( v3 ) );
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( s.contains( v2 ));
+            ASSERT_RCU_FIND( s.contains( v3 ) );
             CPPUNIT_ASSERT( check_size( s, 2 ));
             CPPUNIT_ASSERT( !s.empty() );
 
-            ASSERT_RCU_FIND( !s.find( v4 ));
+            ASSERT_RCU_FIND( !s.contains( v4 ));
             CPPUNIT_ASSERT( s.insert(v4));
-            ASSERT_RCU_FIND( s.find( v4.key() ));
+            ASSERT_RCU_FIND( s.contains( v4.key() ));
             CPPUNIT_ASSERT( s.erase_with( v4.key(), less<value_type>() ));
-            ASSERT_RCU_FIND( !s.find( v4.key() ));
+            ASSERT_RCU_FIND( !s.contains( v4.key() ));
 
             CPPUNIT_ASSERT( s.erase( v2.key() ));
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( !s.find( v2 ));
-            ASSERT_RCU_FIND( s.find( v3 ) );
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v2 ));
+            ASSERT_RCU_FIND( s.contains( v3 ) );
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( !s.erase( v2.key() ));
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( !s.find( v2 ));
-            ASSERT_RCU_FIND( s.find( v3 ) );
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v2 ));
+            ASSERT_RCU_FIND( s.contains( v3 ) );
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( v3.nEraseCount == 0 );
             CPPUNIT_ASSERT( s.erase( v3, erase_functor() ));
             CPPUNIT_ASSERT( v3.nEraseCount == 1 );
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( !s.find( v2 ));
-            ASSERT_RCU_FIND( !s.find( v3 ));
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v2 ));
+            ASSERT_RCU_FIND( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 0 ));
             CPPUNIT_ASSERT( s.empty() );
 
@@ -950,30 +994,30 @@ namespace set {
             }
 
             CPPUNIT_ASSERT( s.unlink( v3 ) );
-            ASSERT_RCU_FIND( s.find( v1 ));
-            ASSERT_RCU_FIND( !s.find( v2 ));
-            ASSERT_RCU_FIND( !s.find( v3 ));
+            ASSERT_RCU_FIND( s.contains( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v2 ));
+            ASSERT_RCU_FIND( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( !s.unlink( v3 ));
-            ASSERT_RCU_FIND( s.find( v1 ));
-            ASSERT_RCU_FIND( !s.find( v2 ));
-            ASSERT_RCU_FIND( !s.find( v3 ));
+            ASSERT_RCU_FIND( s.contains( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v2 ));
+            ASSERT_RCU_FIND( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
             CPPUNIT_ASSERT( s.unlink( v1 ));
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( !s.find( v2 ));
-            ASSERT_RCU_FIND( !s.find( v3 ));
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v2 ));
+            ASSERT_RCU_FIND( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 0 ));
             CPPUNIT_ASSERT( s.empty() );
 
             CPPUNIT_ASSERT( !s.unlink( v2 ));
-            ASSERT_RCU_FIND( !s.find( v1 ));
-            ASSERT_RCU_FIND( !s.find( v2 ));
-            ASSERT_RCU_FIND( !s.find( v3 ));
+            ASSERT_RCU_FIND( !s.contains( v1 ));
+            ASSERT_RCU_FIND( !s.contains( v2 ));
+            ASSERT_RCU_FIND( !s.contains( v3 ));
             CPPUNIT_ASSERT( check_size( s, 0 ));
             CPPUNIT_ASSERT( s.empty() );
 

diff --git a/tests/test-hdr/set/hdr_intrusive_skiplist_set.h b/tests/test-hdr/set/hdr_intrusive_skiplist_set.h
index 04b0ddce33fc6b58d08748f457a80446084387f3..29afe147fdca4e5e8d732c428d9b67eb567004b4 100644 (file)
--- a/tests/test-hdr/set/hdr_intrusive_skiplist_set.h
+++ b/tests/test-hdr/set/hdr_intrusive_skiplist_set.h
@@ -97,7 +97,7 @@ namespace set {
             nPrevKey = 0;
             for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
                 CPPUNIT_ASSERT( (*it).nKey * 2 == it->nVal );
-                CPPUNIT_ASSERT( s.find( it->nKey ));
+                CPPUNIT_ASSERT( s.contains( it->nKey ));
                 it->nVal = (*it).nKey;
                 ++nCount;
                 if ( it != s.begin() ) {
@@ -122,7 +122,7 @@ namespace set {
 
             for ( size_t i = 0; i < sizeof(v)/sizeof(v[0]); ++i ) {
                 CPPUNIT_ASSERT( v[i].nKey == v[i].nVal );
-                CPPUNIT_ASSERT( s.find_with( v[i].nKey, less() ));
+                CPPUNIT_ASSERT( s.contains( v[i].nKey, less() ));
             }
 
             s.clear();
@@ -363,13 +363,13 @@ namespace set {
             CPPUNIT_ASSERT( check_size( s, 0 ));
 
             // insert/find test
-            CPPUNIT_ASSERT( s.find( v1.key() ) == nullptr );
+            CPPUNIT_ASSERT( s.contains( v1.key() ) == nullptr );
             CPPUNIT_ASSERT( s.insert( v1 ));
-            CPPUNIT_ASSERT( s.find( v1.key() ) == &v1 );
+            CPPUNIT_ASSERT( s.contains( v1.key() ) == &v1 );
             CPPUNIT_ASSERT( check_size( s, 1 ));
             CPPUNIT_ASSERT( !s.empty() );
 
-            CPPUNIT_ASSERT( s.find_with( v2.key(), less() ) == nullptr );
+            CPPUNIT_ASSERT( s.contains( v2.key(), less() ) == nullptr );
             CPPUNIT_ASSERT( s.insert( v2 ));
             CPPUNIT_ASSERT( v2.nFindCount == 0 );
             CPPUNIT_ASSERT( s.find_with( key = v2.key(), less(), find_functor() ));
@@ -380,7 +380,7 @@ namespace set {
 
             {
                 find_functor    ff;
-                CPPUNIT_ASSERT( s.find( v3 ) == nullptr );
+                CPPUNIT_ASSERT( s.contains( v3 ) == nullptr );
                 CPPUNIT_ASSERT( s.insert( v3 ));
                 CPPUNIT_ASSERT( v3.nFindCount == 0 );
                 CPPUNIT_ASSERT( s.find( v3, std::ref(ff) ));
@@ -396,71 +396,69 @@ namespace set {
             CPPUNIT_ASSERT( check_size( s, 0 ));
             //CPPUNIT_MSG( PrintStat()(s, "Insert test") );
 
-            ensure_functor f;
+            update_functor f;
             std::pair<bool, bool> ret = s.update( v1, f, true );
             CPPUNIT_ASSERT( ret.first );
             CPPUNIT_ASSERT( ret.second );
-            CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
-            CPPUNIT_ASSERT( v1.nEnsureCount == 0 );
+            CPPUNIT_ASSERT( v1.nUpdateNewCount == 1 );
+            CPPUNIT_ASSERT( v1.nUpdateCount == 0 );
             CPPUNIT_ASSERT( check_size( s, 1 ));
 
             ret = s.update( v2, f, false );
             CPPUNIT_ASSERT( !ret.first );
             CPPUNIT_ASSERT( !ret.second );
-            CPPUNIT_ASSERT( v2.nEnsureNewCount == 0 );
-            CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
+            CPPUNIT_ASSERT( v2.nUpdateNewCount == 0 );
+            CPPUNIT_ASSERT( v2.nUpdateCount == 0 );
             CPPUNIT_ASSERT( check_size( s, 1 ));
 
             ret = s.update( v2, f );
             CPPUNIT_ASSERT( ret.first );
             CPPUNIT_ASSERT( ret.second );
-            CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
-            CPPUNIT_ASSERT( v2.nEnsureCount == 0 );
+            CPPUNIT_ASSERT( v2.nUpdateNewCount == 1 );
+            CPPUNIT_ASSERT( v2.nUpdateCount == 0 );
             CPPUNIT_ASSERT( check_size( s, 2 ));
 
             ret = s.update( v3, f, true );
             CPPUNIT_ASSERT( ret.first );
             CPPUNIT_ASSERT( ret.second );
-            CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
-            CPPUNIT_ASSERT( v3.nEnsureCount == 0 );
+            CPPUNIT_ASSERT( v3.nUpdateNewCount == 1 );
+            CPPUNIT_ASSERT( v3.nUpdateCount == 0 );
             CPPUNIT_ASSERT( check_size( s, 3 ));
 
-            CPPUNIT_ASSERT( s.find( v1 ) == &v1 );
-            CPPUNIT_ASSERT( s.find_with( v2, base_class::less<value_type>() ) == &v2 );
-            CPPUNIT_ASSERT( s.find( v3 ) == &v3 );
+            CPPUNIT_ASSERT( s.contains( v1 ) == &v1 );
+            CPPUNIT_ASSERT( s.contains( v2, base_class::less<value_type>() ) == &v2 );
+            CPPUNIT_ASSERT( s.contains( v3 ) == &v3 );
 
             ret = s.update( v1, f, true );
             CPPUNIT_ASSERT( ret.first );
             CPPUNIT_ASSERT( !ret.second );
-            CPPUNIT_ASSERT( v1.nEnsureNewCount == 1 );
-            CPPUNIT_ASSERT( v1.nEnsureCount == 1 );
+            CPPUNIT_ASSERT( v1.nUpdateNewCount == 1 );
+            CPPUNIT_ASSERT( v1.nUpdateCount == 1 );
             CPPUNIT_ASSERT( check_size( s, 3 ));
 
             ret = s.update( v2, f, false );
             CPPUNIT_ASSERT( ret.first );
             CPPUNIT_ASSERT( !ret.second );
-            CPPUNIT_ASSERT( v2.nEnsureNewCount == 1 );
-            CPPUNIT_ASSERT( v2.nEnsureCount == 1 );
+            CPPUNIT_ASSERT( v2.nUpdateNewCount == 1 );
+            CPPUNIT_ASSERT( v2.nUpdateCount == 1 );
             CPPUNIT_ASSERT( check_size( s, 3 ));
 
             ret = s.update( v3, f );
             CPPUNIT_ASSERT( ret.first );
             CPPUNIT_ASSERT( !ret.second );
-            CPPUNIT_ASSERT( v3.nEnsureNewCount == 1 );
-            CPPUNIT_ASSERT( v3.nEnsureCount == 1 );
+            CPPUNIT_ASSERT( v3.nUpdateNewCount == 1 );
+            CPPUNIT_ASSERT( v3.nUpdateCount == 1 );
             CPPUNIT_ASSERT( check_size( s, 3 ));
 
-            CPPUNIT_ASSERT( s.find( v1 ) == &v1 );
-            CPPUNIT_ASSERT( s.find( v2 ) == &v2 );
-            CPPUNIT_ASSERT( s.find( v3 ) == &v3 );
+            CPPUNIT_ASSERT( s.contains( v1 ) == &v1 );
+            CPPUNIT_ASSERT( s.contains( v2 ) == &v2 );
+            CPPUNIT_ASSERT( s.contains( v3 ) == &v3 );
 
             CPPUNIT_ASSERT( !s.empty() );
             s.clear();
             CPPUNIT_ASSERT( s.empty() );
             CPPUNIT_ASSERT( check_size( s, 0 ));
 
-            //CPPUNIT_MSG( PrintStat()(s, "Ensure test") );
-
             // get_min test
             CPPUNIT_CHECK( s.get_min() == nullptr );
             CPPUNIT_CHECK( s.get_max() == nullptr );

diff --git a/tests/test-hdr/set/hdr_intrusive_skiplist_set_rcu.h b/tests/test-hdr/set/hdr_intrusive_skiplist_set_rcu.h
index be46d3fdda83f617d13d2d2eedcbc7fb9f99aa25..b7dfd78f5870f56b4deeb7ff6f313a0e3e20e469 100644 (file)
--- a/tests/test-hdr/set/hdr_intrusive_skiplist_set_rcu.h
+++ b/tests/test-hdr/set/hdr_intrusive_skiplist_set_rcu.h
@@ -109,7 +109,7 @@ namespace set {
                 rcu_lock l;
                 for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
                     CPPUNIT_ASSERT( (*it).nKey * 2 == it->nVal );
-                    CPPUNIT_ASSERT( s.find( it->nKey ));
+                    CPPUNIT_ASSERT( s.contains( it->nKey ));
                     it->nVal = (*it).nKey;
                     ++nCount;
                     if ( it != s.begin() ) {
@@ -138,7 +138,7 @@ namespace set {
 
             for ( size_t i = 0; i < sizeof(v)/sizeof(v[0]); ++i ) {
                 CPPUNIT_ASSERT( v[i].nKey == v[i].nVal );
-                CPPUNIT_ASSERT( s.find( v[i].nKey ));
+                CPPUNIT_ASSERT( s.contains( v[i].nKey ));
             }
 
             s.clear();

diff --git a/tests/test-hdr/set/hdr_set.h b/tests/test-hdr/set/hdr_set.h
index 2d23869b694777ac69d7a3fb52cfac925ad930c9..88438c7df5415cfc44d3919897db8eb946b5cf02 100644 (file)
--- a/tests/test-hdr/set/hdr_set.h
+++ b/tests/test-hdr/set/hdr_set.h
@@ -29,8 +29,8 @@ namespace set {
         struct stat
         {
             unsigned int nFindCount     ;   // count of find-functor calling
-            unsigned int nEnsureNewCount;
-            unsigned int nEnsureCount;
+            unsigned int nUpdateNewCount;
+            unsigned int nUpdateCount;
 
             stat()
             {
@@ -40,8 +40,8 @@ namespace set {
             void copy( stat const& s )
             {
                 nFindCount = s.nFindCount;
-                nEnsureCount = s.nEnsureCount;
-                nEnsureNewCount = s.nEnsureNewCount;
+                nUpdateCount = s.nUpdateCount;
+                nUpdateNewCount = s.nUpdateNewCount;
             }
         };
 
@@ -321,20 +321,20 @@ namespace set {
         };
 
         template <typename Item, typename Q>
-        static void ensure_func( bool bNew, Item& i, Q& /*val*/ )
+        static void udate_func( bool bNew, Item& i, Q& /*val*/ )
         {
             if ( bNew )
-                ++i.nEnsureNewCount;
+                ++i.nUpdateNewCount;
             else
-                ++i.nEnsureCount;
+                ++i.nUpdateCount;
         }
 
-        struct ensure_functor
+        struct udate_functor
         {
             template <typename Item, typename Q>
             void operator()( bool bNew, Item& i, Q& val )
             {
-                ensure_func( bNew, i, val );
+                udate_func( bNew, i, val );
             }
         };
 
@@ -594,22 +594,22 @@ namespace set {
             int key;
 
             // insert/find test
-            CPPUNIT_ASSERT( !s.find( 10 ) );
+            CPPUNIT_ASSERT( !s.contains( 10 ) );
             CPPUNIT_ASSERT( s.insert( 10 ));
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 1 ));
-            CPPUNIT_ASSERT( s.find( 10 ) );
+            CPPUNIT_ASSERT( s.contains( 10 ) );
 
             CPPUNIT_ASSERT( !s.insert( 10 ));
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 1 ));
 
-            CPPUNIT_ASSERT( !s.find_with( 20, less<value_type>() ) );
+            CPPUNIT_ASSERT( !s.contains( 20, less<value_type>() ) );
             CPPUNIT_ASSERT( s.insert( std::make_pair(20, 25) ));
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 2 ));
-            CPPUNIT_ASSERT( s.find_with( 10, less<value_type>() ) );
-            CPPUNIT_ASSERT( s.find( key = 20 ) );
+            CPPUNIT_ASSERT( s.contains( 10, less<value_type>() ) );
+            CPPUNIT_ASSERT( s.contains( key = 20 ) );
             CPPUNIT_ASSERT( s.find_with( key, less<value_type>(), find_functor() ) );
             {
                 copy_found<item> f;
@@ -631,7 +631,7 @@ namespace set {
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 2 ));
 
-            CPPUNIT_ASSERT( !s.find( 25 ) );
+            CPPUNIT_ASSERT( !s.contains( 25 ) );
             CPPUNIT_ASSERT( s.insert( std::make_pair(25, -1), insert_functor() ));
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 3 ));
@@ -643,18 +643,18 @@ namespace set {
                 CPPUNIT_ASSERT( f.m_found.nVal == 2500 );
             }
 
-            // ensure test
+            // update test
             key = 10;
             {
                 copy_found<item> f;
                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
                 CPPUNIT_ASSERT( f.m_found.nKey == 10 );
                 CPPUNIT_ASSERT( f.m_found.nVal == 10 );
-                CPPUNIT_ASSERT( f.m_found.nEnsureCount == 0 );
-                CPPUNIT_ASSERT( f.m_found.nEnsureNewCount == 0 );
+                CPPUNIT_ASSERT( f.m_found.nUpdateCount == 0 );
+                CPPUNIT_ASSERT( f.m_found.nUpdateNewCount == 0 );
             }
-            std::pair<bool, bool> ensureResult = s.ensure( key, ensure_functor() );
-            CPPUNIT_ASSERT( ensureResult.first && !ensureResult.second );
+            std::pair<bool, bool> updateResult = s.update( key, udate_functor() );
+            CPPUNIT_ASSERT( updateResult.first && !updateResult.second );
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 3 ));
             {
@@ -662,12 +662,16 @@ namespace set {
                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
                 CPPUNIT_ASSERT( f.m_found.nKey == 10 );
                 CPPUNIT_ASSERT( f.m_found.nVal == 10 );
-                CPPUNIT_ASSERT( f.m_found.nEnsureCount == 1 );
-                CPPUNIT_ASSERT( f.m_found.nEnsureNewCount == 0 );
+                CPPUNIT_ASSERT( f.m_found.nUpdateCount == 1 );
+                CPPUNIT_ASSERT( f.m_found.nUpdateNewCount == 0 );
             }
 
-            ensureResult = s.ensure( std::make_pair(13, 1300), ensure_functor() );
-            CPPUNIT_ASSERT( ensureResult.first && ensureResult.second );
+            updateResult = s.update(std::make_pair(13, 1300), udate_functor(), false);
+            CPPUNIT_ASSERT(!updateResult.first && !updateResult.second);
+            CPPUNIT_ASSERT(check_size(s, 3));
+
+            updateResult = s.update( std::make_pair(13, 1300), udate_functor() );
+            CPPUNIT_ASSERT( updateResult.first && updateResult.second );
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 4 ));
             {
@@ -676,29 +680,29 @@ namespace set {
                 CPPUNIT_ASSERT( s.find( key, std::ref( f ) ) );
                 CPPUNIT_ASSERT( f.m_found.nKey == 13 );
                 CPPUNIT_ASSERT( f.m_found.nVal == 1300 );
-                CPPUNIT_ASSERT( f.m_found.nEnsureCount == 0 );
-                CPPUNIT_ASSERT( f.m_found.nEnsureNewCount == 1 );
+                CPPUNIT_ASSERT( f.m_found.nUpdateCount == 0 );
+                CPPUNIT_ASSERT( f.m_found.nUpdateNewCount == 1 );
             }
 
             // erase test
             CPPUNIT_ASSERT( s.erase(13) );
-            CPPUNIT_ASSERT( !s.find( 13 ));
+            CPPUNIT_ASSERT( !s.contains( 13 ));
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 3 ));
             CPPUNIT_ASSERT( !s.erase(13) );
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 3 ));
 
-            CPPUNIT_ASSERT( s.find( 10 ));
+            CPPUNIT_ASSERT( s.contains( 10 ));
             CPPUNIT_ASSERT( s.erase_with( 10, less<value_type>() ));
-            CPPUNIT_ASSERT( !s.find( 10 ));
+            CPPUNIT_ASSERT( !s.contains( 10 ));
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 2 ));
             CPPUNIT_ASSERT( !s.erase_with(10, less<value_type>()) );
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 2 ));
 
-            CPPUNIT_ASSERT( s.find(20) );
+            CPPUNIT_ASSERT( s.contains(20) );
             {
                 copy_found<item> f;
                 CPPUNIT_ASSERT( s.erase( 20, std::ref( f ) ) );
@@ -710,7 +714,7 @@ namespace set {
                 CPPUNIT_ASSERT( f.m_found.nKey == 235 );
                 CPPUNIT_ASSERT( f.m_found.nVal == 235 );
             }
-            CPPUNIT_ASSERT( !s.find( 20 ));
+            CPPUNIT_ASSERT( !s.contains( 20 ));
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 1 ));
 
@@ -725,9 +729,9 @@ namespace set {
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 3 ));
 
-            CPPUNIT_ASSERT( s.find(151));
-            CPPUNIT_ASSERT( s.find_with(174, less<value_type>()));
-            CPPUNIT_ASSERT( s.find(190));
+            CPPUNIT_ASSERT( s.contains(151));
+            CPPUNIT_ASSERT( s.contains(174, less<value_type>()));
+            CPPUNIT_ASSERT( s.contains(190));
 
             {
                 copy_found<item> f;
@@ -784,53 +788,58 @@ namespace set {
                 CPPUNIT_ASSERT( check_size( s, 2 ));
                 CPPUNIT_ASSERT( s.insert( 50 ) == s.end() );
 
-                // ensure
-                std::pair< iterator, bool>  ensureResult;
-                ensureResult = s.ensure( 20 );
-                CPPUNIT_ASSERT( ensureResult.first != s.end() );
-                CPPUNIT_ASSERT( ensureResult.second  );
-                CPPUNIT_ASSERT( ensureResult.first->key() == 20 );
-                CPPUNIT_ASSERT( ensureResult.first->val() == 20 );
+                // update
+                std::pair< iterator, bool>  updateResult;
+                updateResult = s.update(20, false);
+                CPPUNIT_ASSERT(updateResult.first == s.end());
+                CPPUNIT_ASSERT(!updateResult.second);
+                CPPUNIT_ASSERT(check_size(s, 2));
+
+                updateResult = s.update( 20 );
+                CPPUNIT_ASSERT( updateResult.first != s.end() );
+                CPPUNIT_ASSERT( updateResult.second  );
+                CPPUNIT_ASSERT( updateResult.first->key() == 20 );
+                CPPUNIT_ASSERT( updateResult.first->val() == 20 );
                 CPPUNIT_ASSERT( !s.empty() );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                ensureResult = s.ensure( std::make_pair( 20, 200 ));
-                CPPUNIT_ASSERT( ensureResult.first != s.end() );
-                CPPUNIT_ASSERT( !ensureResult.second  );
-                CPPUNIT_ASSERT( ensureResult.first->key() == 20 );
-                CPPUNIT_ASSERT( ensureResult.first->val() == 20 );
+                updateResult = s.update( std::make_pair( 20, 200 ));
+                CPPUNIT_ASSERT( updateResult.first != s.end() );
+                CPPUNIT_ASSERT( !updateResult.second  );
+                CPPUNIT_ASSERT( updateResult.first->key() == 20 );
+                CPPUNIT_ASSERT( updateResult.first->val() == 20 );
                 CPPUNIT_ASSERT( !s.empty() );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
-                ensureResult.first->nVal = 22;
+                updateResult.first->nVal = 22;
 
-                ensureResult = s.ensure( std::make_pair( 30, 33 ));
-                CPPUNIT_ASSERT( ensureResult.first != s.end() );
-                CPPUNIT_ASSERT( ensureResult.second  );
-                CPPUNIT_ASSERT( ensureResult.first->key() == 30 );
-                CPPUNIT_ASSERT( ensureResult.first->val() == 33 );
+                updateResult = s.update( std::make_pair( 30, 33 ));
+                CPPUNIT_ASSERT( updateResult.first != s.end() );
+                CPPUNIT_ASSERT( updateResult.second  );
+                CPPUNIT_ASSERT( updateResult.first->key() == 30 );
+                CPPUNIT_ASSERT( updateResult.first->val() == 33 );
                 CPPUNIT_ASSERT( !s.empty() );
                 CPPUNIT_ASSERT( check_size( s, 4 ));
 
                 // find
-                it = s.find( 10 );
+                it = s.contains( 10 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 10 );
                 CPPUNIT_ASSERT( it->val() == 10 );
 
-                it = s.find_with( 20, less<value_type>() );
+                it = s.contains( 20, less<value_type>() );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 20 );
                 CPPUNIT_ASSERT( it->val() == 22 );
 
-                it = s.find( 30 );
+                it = s.contains( 30 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 30 );
                 CPPUNIT_ASSERT( it->val() == 33 );
 
-                it = s.find( 40 );
+                it = s.contains( 40 );
                 CPPUNIT_ASSERT( it == s.end() );
 
-                it = s.find( 50 );
+                it = s.contains( 50 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 50 );
                 CPPUNIT_ASSERT( it->val() == 25 );
@@ -851,17 +860,17 @@ namespace set {
                 CPPUNIT_ASSERT( it->key() == 190 );
                 CPPUNIT_ASSERT( it->val() == 91 );
 
-                it = s.find( 174 );
+                it = s.contains( 174 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 174 );
                 CPPUNIT_ASSERT( it->val() == 471 );
 
-                it = s.find_with( 190, less<value_type>() );
+                it = s.contains( 190, less<value_type>() );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 190 );
                 CPPUNIT_ASSERT( it->val() == 91 );
 
-                it = s.find( 151 );
+                it = s.contains( 151 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 151 );
                 CPPUNIT_ASSERT( it->val() == 151 );
@@ -924,53 +933,58 @@ namespace set {
                 CPPUNIT_ASSERT( check_size( s, 2 ));
                 CPPUNIT_ASSERT( s.insert( 50 ) == s.end() );
 
-                // ensure
-                std::pair< iterator, bool>  ensureResult;
-                ensureResult = s.ensure( 20 );
-                CPPUNIT_ASSERT( ensureResult.first != s.end() );
-                CPPUNIT_ASSERT( ensureResult.second  );
-                CPPUNIT_ASSERT( ensureResult.first->key() == 20 );
-                CPPUNIT_ASSERT( ensureResult.first->val() == 20 );
+                // update
+                std::pair< iterator, bool>  updateResult;
+                updateResult = s.update(20, false);
+                CPPUNIT_ASSERT(updateResult.first == s.end());
+                CPPUNIT_ASSERT(!updateResult.second);
+                CPPUNIT_ASSERT(check_size(s, 2));
+
+                updateResult = s.update( 20 );
+                CPPUNIT_ASSERT( updateResult.first != s.end() );
+                CPPUNIT_ASSERT( updateResult.second  );
+                CPPUNIT_ASSERT( updateResult.first->key() == 20 );
+                CPPUNIT_ASSERT( updateResult.first->val() == 20 );
                 CPPUNIT_ASSERT( !s.empty() );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
 
-                ensureResult = s.ensure( std::make_pair( 20, 200 ));
-                CPPUNIT_ASSERT( ensureResult.first != s.end() );
-                CPPUNIT_ASSERT( !ensureResult.second  );
-                CPPUNIT_ASSERT( ensureResult.first->key() == 20 );
-                CPPUNIT_ASSERT( ensureResult.first->val() == 20 );
+                updateResult = s.update( std::make_pair( 20, 200 ));
+                CPPUNIT_ASSERT( updateResult.first != s.end() );
+                CPPUNIT_ASSERT( !updateResult.second  );
+                CPPUNIT_ASSERT( updateResult.first->key() == 20 );
+                CPPUNIT_ASSERT( updateResult.first->val() == 20 );
                 CPPUNIT_ASSERT( !s.empty() );
                 CPPUNIT_ASSERT( check_size( s, 3 ));
-                ensureResult.first->nVal = 22;
+                updateResult.first->nVal = 22;
 
-                ensureResult = s.ensure( std::make_pair( 30, 33 ));
-                CPPUNIT_ASSERT( ensureResult.first != s.end() );
-                CPPUNIT_ASSERT( ensureResult.second  );
-                CPPUNIT_ASSERT( ensureResult.first->key() == 30 );
-                CPPUNIT_ASSERT( ensureResult.first->val() == 33 );
+                updateResult = s.update( std::make_pair( 30, 33 ));
+                CPPUNIT_ASSERT( updateResult.first != s.end() );
+                CPPUNIT_ASSERT( updateResult.second  );
+                CPPUNIT_ASSERT( updateResult.first->key() == 30 );
+                CPPUNIT_ASSERT( updateResult.first->val() == 33 );
                 CPPUNIT_ASSERT( !s.empty() );
                 CPPUNIT_ASSERT( check_size( s, 4 ));
 
                 // find
-                it = s.find( 10 );
+                it = s.contains( 10 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 10 );
                 CPPUNIT_ASSERT( it->val() == 10 );
 
-                it = s.find_with( 20, equal<value_type>() );
+                it = s.contains( 20, equal<value_type>() );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 20 );
                 CPPUNIT_ASSERT( it->val() == 22 );
 
-                it = s.find( 30 );
+                it = s.contains( 30 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 30 );
                 CPPUNIT_ASSERT( it->val() == 33 );
 
-                it = s.find( 40 );
+                it = s.contains( 40 );
                 CPPUNIT_ASSERT( it == s.end() );
 
-                it = s.find( 50 );
+                it = s.contains( 50 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 50 );
                 CPPUNIT_ASSERT( it->val() == 25 );
@@ -991,17 +1005,17 @@ namespace set {
                 CPPUNIT_ASSERT( it->key() == 190 );
                 CPPUNIT_ASSERT( it->val() == 91 );
 
-                it = s.find( 174 );
+                it = s.contains( 174 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 174 );
                 CPPUNIT_ASSERT( it->val() == 471 );
 
-                it = s.find_with( 190, equal<value_type>() );
+                it = s.contains( 190, equal<value_type>() );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 190 );
                 CPPUNIT_ASSERT( it->val() == 91 );
 
-                it = s.find( 151 );
+                it = s.contains( 151 );
                 CPPUNIT_ASSERT( it != s.end() );
                 CPPUNIT_ASSERT( it->key() == 151 );
                 CPPUNIT_ASSERT( it->val() == 151 );

diff --git a/tests/test-hdr/set/hdr_skiplist_set.h b/tests/test-hdr/set/hdr_skiplist_set.h
index 31ed877977e70b873c288621a62bda91b3ecf2d7..417dd65322da0c488abf0d5683a7c746b74bdf75 100644 (file)
--- a/tests/test-hdr/set/hdr_skiplist_set.h
+++ b/tests/test-hdr/set/hdr_skiplist_set.h
@@ -58,7 +58,7 @@ namespace set {
             nPrevKey = 0;
             for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
                 CPPUNIT_ASSERT( (*it).nKey == it->nVal );
-                CPPUNIT_ASSERT( s.find( it->nKey ));
+                CPPUNIT_ASSERT( s.contains( it->nKey ));
                 it->nVal = (*it).nKey * 2;
                 ++nCount;
                 if ( it != s.begin() ) {
@@ -112,7 +112,7 @@ namespace set {
             nPrevKey = 0;
             for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
                 CPPUNIT_ASSERT( (*it).nKey * 2 == it->nVal );
-                CPPUNIT_ASSERT( s.find( it->nKey ));
+                CPPUNIT_ASSERT( s.contains( it->nKey ));
                 it->nVal = (*it).nKey;
                 ++nCount;
                 if ( it != s.begin() ) {
@@ -146,7 +146,7 @@ namespace set {
             nPrevKey = 0;
             for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
                 CPPUNIT_ASSERT( (*it).nKey == it->nVal );
-                CPPUNIT_ASSERT( s.find( it->nKey ));
+                CPPUNIT_ASSERT( s.contains( it->nKey ));
                 it->nVal = (*it).nKey * 2;
                 ++nCount;
                 if ( it != s.begin() ) {
@@ -294,53 +294,58 @@ namespace set {
             CPPUNIT_ASSERT( check_size( s, 2 ));
             CPPUNIT_ASSERT( s.insert( 50 ) == s.end() );
 
-            // ensure
-            std::pair< iterator, bool>  ensureResult;
-            ensureResult = s.ensure( 20 );
-            CPPUNIT_ASSERT( ensureResult.first != s.end() );
-            CPPUNIT_ASSERT( ensureResult.second  );
-            CPPUNIT_ASSERT( ensureResult.first->key() == 20 );
-            CPPUNIT_ASSERT( ensureResult.first->val() == 20 );
+            // update
+            std::pair< iterator, bool>  updateResult;
+            updateResult = s.update(20, false);
+            CPPUNIT_ASSERT(updateResult.first == s.end());
+            CPPUNIT_ASSERT(!updateResult.second);
+            CPPUNIT_ASSERT(check_size(s, 2));
+
+            updateResult = s.update( 20 );
+            CPPUNIT_ASSERT( updateResult.first != s.end() );
+            CPPUNIT_ASSERT( updateResult.second  );
+            CPPUNIT_ASSERT( updateResult.first->key() == 20 );
+            CPPUNIT_ASSERT( updateResult.first->val() == 20 );
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 3 ));
 
-            ensureResult = s.ensure( std::make_pair( 20, 200 ));
-            CPPUNIT_ASSERT( ensureResult.first != s.end() );
-            CPPUNIT_ASSERT( !ensureResult.second  );
-            CPPUNIT_ASSERT( ensureResult.first->key() == 20 );
-            CPPUNIT_ASSERT( ensureResult.first->val() == 20 );
+            updateResult = s.update( std::make_pair( 20, 200 ));
+            CPPUNIT_ASSERT( updateResult.first != s.end() );
+            CPPUNIT_ASSERT( !updateResult.second  );
+            CPPUNIT_ASSERT( updateResult.first->key() == 20 );
+            CPPUNIT_ASSERT( updateResult.first->val() == 20 );
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 3 ));
-            ensureResult.first->nVal = 22;
+            updateResult.first->nVal = 22;
 
-            ensureResult = s.ensure( std::make_pair( 30, 33 ));
-            CPPUNIT_ASSERT( ensureResult.first != s.end() );
-            CPPUNIT_ASSERT( ensureResult.second  );
-            CPPUNIT_ASSERT( ensureResult.first->key() == 30 );
-            CPPUNIT_ASSERT( ensureResult.first->val() == 33 );
+            updateResult = s.update( std::make_pair( 30, 33 ));
+            CPPUNIT_ASSERT( updateResult.first != s.end() );
+            CPPUNIT_ASSERT( updateResult.second  );
+            CPPUNIT_ASSERT( updateResult.first->key() == 30 );
+            CPPUNIT_ASSERT( updateResult.first->val() == 33 );
             CPPUNIT_ASSERT( !s.empty() );
             CPPUNIT_ASSERT( check_size( s, 4 ));
 
             // find
-            it = s.find( 10 );
+            it = s.contains( 10 );
             CPPUNIT_ASSERT( it != s.end() );
             CPPUNIT_ASSERT( it->key() == 10 );
             CPPUNIT_ASSERT( it->val() == 10 );
 
-            it = s.find( 20 );
+            it = s.contains( 20 );
             CPPUNIT_ASSERT( it != s.end() );
             CPPUNIT_ASSERT( it->key() == 20 );
             CPPUNIT_ASSERT( it->val() == 22 );
 
-            it = s.find_with( 30, base_class::less<value_type>() );
+            it = s.contains( 30, base_class::less<value_type>() );
             CPPUNIT_ASSERT( it != s.end() );
             CPPUNIT_ASSERT( it->key() == 30 );
             CPPUNIT_ASSERT( it->val() == 33 );
 
-            it = s.find( 40 );
+            it = s.contains( 40 );
             CPPUNIT_ASSERT( it == s.end() );
 
-            it = s.find( 50 );
+            it = s.contains( 50 );
             CPPUNIT_ASSERT( it != s.end() );
             CPPUNIT_ASSERT( it->key() == 50 );
             CPPUNIT_ASSERT( it->val() == 25 );
@@ -361,17 +366,17 @@ namespace set {
             CPPUNIT_ASSERT( it->key() == 190 );
             CPPUNIT_ASSERT( it->val() == 91 );
 
-            it = s.find( 174 );
+            it = s.contains( 174 );
             CPPUNIT_ASSERT( it != s.end() );
             CPPUNIT_ASSERT( it->key() == 174 );
             CPPUNIT_ASSERT( it->val() == 471 );
 
-            it = s.find( 190 );
+            it = s.contains( 190 );
             CPPUNIT_ASSERT( it != s.end() );
             CPPUNIT_ASSERT( it->key() == 190 );
             CPPUNIT_ASSERT( it->val() == 91 );
 
-            it = s.find( 151 );
+            it = s.contains( 151 );
             CPPUNIT_ASSERT( it != s.end() );
             CPPUNIT_ASSERT( it->key() == 151 );
             CPPUNIT_ASSERT( it->val() == 151 );

diff --git a/tests/test-hdr/set/hdr_skiplist_set_rcu.h b/tests/test-hdr/set/hdr_skiplist_set_rcu.h
index f84b322b92e35dbdf9f882fb2c182adc1b4c44eb..c42c588ee73a4d0d3bff660d9fc076f84793ee75 100644 (file)
--- a/tests/test-hdr/set/hdr_skiplist_set_rcu.h
+++ b/tests/test-hdr/set/hdr_skiplist_set_rcu.h
@@ -48,7 +48,7 @@ namespace set {
                 rcu_lock l;
                 for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
                     CPPUNIT_ASSERT( (*it).nKey == it->nVal );
-                    CPPUNIT_ASSERT( s.find( it->nKey ));
+                    CPPUNIT_ASSERT( s.contains( it->nKey ));
                     it->nVal = (*it).nKey * 2;
                     ++nCount;
                     if ( it != s.begin() ) {
@@ -88,7 +88,7 @@ namespace set {
                 rcu_lock l;
                 for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
                     CPPUNIT_ASSERT( (*it).nKey * 2 == it->nVal );
-                    CPPUNIT_ASSERT( s.find( it->nKey ));
+                    CPPUNIT_ASSERT( s.contains( it->nKey ));
                     it->nVal = (*it).nKey;
                     ++nCount;
                     if ( it != s.begin() ) {
@@ -129,7 +129,7 @@ namespace set {
                 rcu_lock l;
                 for ( set_iterator it = s.begin(), itEnd = s.end(); it != itEnd; ++it ) {
                     CPPUNIT_ASSERT( (*it).nKey == it->nVal );
-                    CPPUNIT_ASSERT( s.find( it->nKey ));
+                    CPPUNIT_ASSERT( s.contains( it->nKey ));
                     it->nVal = (*it).nKey * 2;
                     ++nCount;
                     if ( it != s.begin() ) {
@@ -229,7 +229,7 @@ namespace set {
                     CPPUNIT_ASSERT( !ep.empty() );
                     CPPUNIT_CHECK( ep->nKey == i );
                     CPPUNIT_CHECK( ep->nVal == i );
-                    CPPUNIT_CHECK( !s.find(i) );
+                    CPPUNIT_CHECK( !s.contains(i) );
                     ep.release();
                 }
                 CPPUNIT_CHECK( s.empty());
@@ -244,7 +244,7 @@ namespace set {
                     CPPUNIT_ASSERT( !ep.empty() );
                     CPPUNIT_CHECK( ep->nKey == i );
                     CPPUNIT_CHECK( ep->nVal == i );
-                    CPPUNIT_CHECK( !s.find(i) );
+                    CPPUNIT_CHECK( !s.contains(i) );
                     ep.release();
                 }
                 CPPUNIT_CHECK( s.empty());