From ed8f14e1a76d563966aecb56a0e68f7836244002 Mon Sep 17 00:00:00 2001 From: khizmax Date: Wed, 3 Aug 2016 00:00:12 +0300 Subject: [PATCH] Added unit tests for IterableKVList --- cds/container/impl/iterable_kvlist.h | 2 +- projects/Win/vc14/gtest-list.vcxproj | 1 + projects/Win/vc14/gtest-list.vcxproj.filters | 3 + test/unit/list/kv_iterable_dhp.cpp | 167 +++++++++++++++++++ test/unit/list/kv_iterable_hp.cpp | 18 +- test/unit/list/test_kv_iterable_list.h | 6 +- 6 files changed, 178 insertions(+), 19 deletions(-) create mode 100644 test/unit/list/kv_iterable_dhp.cpp diff --git a/cds/container/impl/iterable_kvlist.h b/cds/container/impl/iterable_kvlist.h index 0cac4538..a483c57f 100644 --- a/cds/container/impl/iterable_kvlist.h +++ b/cds/container/impl/iterable_kvlist.h @@ -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 diff --git a/projects/Win/vc14/gtest-list.vcxproj b/projects/Win/vc14/gtest-list.vcxproj index ab0dc161..24ab1e1f 100644 --- a/projects/Win/vc14/gtest-list.vcxproj +++ b/projects/Win/vc14/gtest-list.vcxproj @@ -101,6 +101,7 @@ + diff --git a/projects/Win/vc14/gtest-list.vcxproj.filters b/projects/Win/vc14/gtest-list.vcxproj.filters index f9a551b6..eec2b0e6 100644 --- a/projects/Win/vc14/gtest-list.vcxproj.filters +++ b/projects/Win/vc14/gtest-list.vcxproj.filters @@ -260,5 +260,8 @@ Source Files\iterable_list + + Source Files\iterable_list + \ 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 index 00000000..9cb97e1e --- /dev/null +++ b/test/unit/list/kv_iterable_dhp.cpp @@ -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 + +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 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 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 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 list_type; + + cds::container::iterable_list::stat<> st; + list_type l( st ); + test_common( l ); + test_ordered_iterator( l ); + test_hp( l ); + } + +} // namespace diff --git a/test/unit/list/kv_iterable_hp.cpp b/test/unit/list/kv_iterable_hp.cpp index cca1577f..84cf2c54 100644 --- a/test/unit/list/kv_iterable_hp.cpp +++ b/test/unit/list/kv_iterable_hp.cpp @@ -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 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 diff --git a/test/unit/list/test_kv_iterable_list.h b/test/unit/list/test_kv_iterable_list.h index 4bb57696..d97f27c6 100644 --- a/test/unit/list/test_kv_iterable_list.h +++ b/test/unit/list/test_kv_iterable_list.h @@ -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 ); -- 2.34.1