Added unit tests for IterableKVList<HP>
authorkhizmax <libcds.dev@gmail.com>
Tue, 2 Aug 2016 21:00:12 +0000 (00:00 +0300)
committerkhizmax <libcds.dev@gmail.com>
Tue, 2 Aug 2016 21:00:12 +0000 (00:00 +0300)
cds/container/impl/iterable_kvlist.h
projects/Win/vc14/gtest-list.vcxproj
projects/Win/vc14/gtest-list.vcxproj.filters
test/unit/list/kv_iterable_dhp.cpp [new file with mode: 0644]
test/unit/list/kv_iterable_hp.cpp
test/unit/list/test_kv_iterable_list.h

index 0cac453..a483c57 100644 (file)
@@ -361,7 +361,7 @@ namespace cds { namespace container {
 #endif
         update( K const& key, Func f, bool bAllowInsert = true )
         {
-            return base_class::update( key, f, bAllowInsert );
+            return base_class::update( value_type( key, mapped_type()), f, bAllowInsert );
         }
 
         /// Insert or update
index ab0dc16..24ab1e1 100644 (file)
     <ClCompile Include="..\..\..\test\unit\list\intrusive_michael_nogc.cpp" />\r
     <ClCompile Include="..\..\..\test\unit\list\iterable_dhp.cpp" />\r
     <ClCompile Include="..\..\..\test\unit\list\iterable_hp.cpp" />\r
+    <ClCompile Include="..\..\..\test\unit\list\kv_iterable_dhp.cpp" />\r
     <ClCompile Include="..\..\..\test\unit\list\kv_iterable_hp.cpp" />\r
     <ClCompile Include="..\..\..\test\unit\list\kv_lazy_dhp.cpp" />\r
     <ClCompile Include="..\..\..\test\unit\list\kv_lazy_hp.cpp" />\r
index f9a551b..eec2b0e 100644 (file)
     <ClCompile Include="..\..\..\test\unit\list\kv_iterable_hp.cpp">\r
       <Filter>Source Files\iterable_list</Filter>\r
     </ClCompile>\r
+    <ClCompile Include="..\..\..\test\unit\list\kv_iterable_dhp.cpp">\r
+      <Filter>Source Files\iterable_list</Filter>\r
+    </ClCompile>\r
   </ItemGroup>\r
 </Project>
\ No newline at end of file
diff --git a/test/unit/list/kv_iterable_dhp.cpp b/test/unit/list/kv_iterable_dhp.cpp
new file mode 100644 (file)
index 0000000..9cb97e1
--- /dev/null
@@ -0,0 +1,167 @@
+/*
+    This file is a part of libcds - Concurrent Data Structures library
+
+    (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
+
+    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:
+
+    * Redistributions of source code must retain the above copyright notice, this
+      list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    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.
+*/
+
+#include "test_kv_iterable_list_hp.h"
+#include <cds/container/iterable_kvlist_dhp.h>
+
+namespace {
+    namespace cc = cds::container;
+    typedef cds::gc::DHP gc_type;
+
+    class IterableKVList_DHP : public cds_test::kv_iterable_list_hp
+    {
+    protected:
+        void SetUp()
+        {
+            typedef cc::IterableKVList< gc_type, key_type, value_type > list_type;
+
+            cds::gc::dhp::GarbageCollector::Construct( 16, list_type::c_nHazardPtrCount );
+            cds::threading::Manager::attachThread();
+        }
+
+        void TearDown()
+        {
+            cds::threading::Manager::detachThread();
+            cds::gc::dhp::GarbageCollector::Destruct();
+        }
+    };
+
+    TEST_F( IterableKVList_DHP, less_ordered )
+    {
+        typedef cc::IterableKVList< gc_type, key_type, value_type,
+            typename cc::iterable_list::make_traits<
+                cds::opt::less< lt >
+                ,cds::opt::item_counter< cds::atomicity::item_counter >
+            >::type
+        > list_type;
+
+        list_type l;
+        test_common( l );
+        test_ordered_iterator( l );
+        test_hp( l );
+    }
+
+    TEST_F( IterableKVList_DHP, compare_ordered )
+    {
+        typedef cc::IterableKVList< gc_type, key_type, value_type,
+            typename cc::iterable_list::make_traits<
+                cds::opt::compare< cmp >
+                , cds::opt::item_counter< cds::atomicity::item_counter >
+            >::type
+        > list_type;
+
+        list_type l;
+        test_common( l );
+        test_ordered_iterator( l );
+        test_hp( l );
+    }
+
+    TEST_F( IterableKVList_DHP, mix_ordered )
+    {
+        typedef cc::IterableKVList< gc_type, key_type, value_type,
+            typename cc::iterable_list::make_traits<
+                cds::opt::compare< cmp >
+                ,cds::opt::less< lt >
+                , cds::opt::item_counter< cds::atomicity::item_counter >
+            >::type
+        > list_type;
+
+        list_type l;
+        test_common( l );
+        test_ordered_iterator( l );
+        test_hp( l );
+    }
+
+    TEST_F( IterableKVList_DHP, backoff )
+    {
+        struct traits : public cc::iterable_list::traits
+        {
+            typedef lt less;
+            typedef cds::atomicity::item_counter item_counter;
+            typedef cds::backoff::empty back_off;
+        };
+        typedef cc::IterableKVList<gc_type, key_type, value_type, traits > list_type;
+
+        list_type l;
+        test_common( l );
+        test_ordered_iterator( l );
+        test_hp( l );
+    }
+
+    TEST_F( IterableKVList_DHP, seq_cst )
+    {
+        struct traits : public cc::iterable_list::traits
+        {
+            typedef lt less;
+            typedef cds::atomicity::item_counter item_counter;
+            typedef cds::opt::v::sequential_consistent memory_model;
+        };
+        typedef cc::IterableKVList<gc_type, key_type, value_type, traits > list_type;
+
+        list_type l;
+        test_common( l );
+        test_ordered_iterator( l );
+        test_hp( l );
+    }
+
+    TEST_F( IterableKVList_DHP, stat )
+    {
+        struct traits: public cc::iterable_list::traits
+        {
+            typedef lt less;
+            typedef cds::atomicity::item_counter item_counter;
+            typedef cds::container::iterable_list::stat<> stat;
+        };
+        typedef cc::IterableKVList<gc_type, key_type, value_type, traits > list_type;
+
+        list_type l;
+        test_common( l );
+        test_ordered_iterator( l );
+        test_hp( l );
+    }
+
+    TEST_F( IterableKVList_DHP, wrapped_stat )
+    {
+        struct traits: public cc::iterable_list::traits
+        {
+            typedef lt less;
+            typedef cds::atomicity::item_counter item_counter;
+            typedef cds::container::iterable_list::wrapped_stat<> stat;
+        };
+        typedef cc::IterableKVList<gc_type, key_type, value_type, traits > list_type;
+
+        cds::container::iterable_list::stat<> st;
+        list_type l( st );
+        test_common( l );
+        test_ordered_iterator( l );
+        test_hp( l );
+    }
+
+} // namespace
index cca1577..84cf2c5 100644 (file)
@@ -59,6 +59,7 @@ namespace {
         typedef cc::IterableKVList< gc_type, key_type, value_type,
             typename cc::iterable_list::make_traits<
                 cds::opt::less< lt >
+                ,cds::opt::item_counter< cds::atomicity::item_counter >
             >::type
         > list_type;
 
@@ -73,6 +74,7 @@ namespace {
         typedef cc::IterableKVList< gc_type, key_type, value_type,
             typename cc::iterable_list::make_traits<
                 cds::opt::compare< cmp >
+                , cds::opt::item_counter< cds::atomicity::item_counter >
             >::type
         > list_type;
 
@@ -88,6 +90,7 @@ namespace {
             typename cc::iterable_list::make_traits<
                 cds::opt::compare< cmp >
                 ,cds::opt::less< lt >
+                , cds::opt::item_counter< cds::atomicity::item_counter >
             >::type
         > list_type;
 
@@ -97,21 +100,6 @@ namespace {
         test_hp( l );
     }
 
-    TEST_F( IterableKVList_HP, item_counting )
-    {
-        struct traits : public cc::iterable_list::traits
-        {
-            typedef lt less;
-            typedef cds::atomicity::item_counter item_counter;
-        };
-        typedef cc::IterableKVList<gc_type, key_type, value_type, traits > list_type;
-
-        list_type l;
-        test_common( l );
-        test_ordered_iterator( l );
-        test_hp( l );
-    }
-
     TEST_F( IterableKVList_HP, backoff )
     {
         struct traits : public cc::iterable_list::traits
index 4bb5769..d97f27c 100644 (file)
@@ -278,7 +278,7 @@ namespace cds_test {
                             EXPECT_TRUE( ret.second );
                             EXPECT_TRUE( l.contains( i.key ) );
 
-                            ret = l.upsert( i.key, i.val * 12 );
+                            ret = l.upsert( i.key, i.key * 12 );
                             EXPECT_TRUE( ret.first );
                             EXPECT_FALSE( ret.second );
                             EXPECT_TRUE( l.find( i.key, []( list_value_type& n ) {
@@ -303,8 +303,8 @@ namespace cds_test {
                 } ));
 
                 auto pair = l.update( i.key, []( list_value_type& n, list_value_type* old ) {
-                    EXPECT_FALSE( old == nullptr );
-                    EXPECT_EQ( n.first.nKey * 5, n.second.val );
+                    ASSERT_FALSE( old == nullptr );
+                    EXPECT_EQ( n.first.nKey * 5, old->second.val );
                     n.second.val = n.first.nKey * 3;
                 }, false );
                 EXPECT_TRUE( pair.first );