| |
| // Copyright 2005-2009 Daniel James. |
| // Distributed under the Boost Software License, Version 1.0. (See accompanying |
| // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| |
| #if defined(BOOST_MSVC) |
| #pragma warning(push) |
| #pragma warning(disable:4100) // unreferenced formal parameter |
| #pragma warning(disable:4610) // class can never be instantiated |
| #pragma warning(disable:4510) // default constructor could not be generated |
| #endif |
| |
| #include <boost/concept_check.hpp> |
| |
| #if defined(BOOST_MSVC) |
| #pragma warning(pop) |
| #endif |
| |
| #include <boost/mpl/assert.hpp> |
| #include <boost/mpl/bool.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #include <boost/type_traits/is_convertible.hpp> |
| #include <boost/iterator/iterator_traits.hpp> |
| #include <boost/limits.hpp> |
| #include "../helpers/check_return_type.hpp" |
| |
| typedef long double comparison_type; |
| |
| template <class T> void sink(T const&) {} |
| template <class T> T rvalue(T const& v) { return v; } |
| |
| template <class X, class T> |
| void container_test(X& r, T const&) |
| { |
| typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; |
| typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator; |
| typedef BOOST_DEDUCED_TYPENAME X::difference_type difference_type; |
| typedef BOOST_DEDUCED_TYPENAME X::size_type size_type; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_value<iterator>::type iterator_value_type; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_value<const_iterator>::type const_iterator_value_type; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_difference<iterator>::type iterator_difference_type; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_difference<const_iterator>::type |
| const_iterator_difference_type; |
| |
| typedef BOOST_DEDUCED_TYPENAME X::value_type value_type; |
| typedef BOOST_DEDUCED_TYPENAME X::reference reference; |
| typedef BOOST_DEDUCED_TYPENAME X::const_reference const_reference; |
| |
| // value_type |
| |
| BOOST_MPL_ASSERT((boost::is_same<T, value_type>)); |
| boost::function_requires<boost::CopyConstructibleConcept<X> >(); |
| |
| // reference_type / const_reference_type |
| |
| BOOST_MPL_ASSERT((boost::is_same<T&, reference>)); |
| BOOST_MPL_ASSERT((boost::is_same<T const&, const_reference>)); |
| |
| // iterator |
| |
| boost::function_requires<boost::InputIteratorConcept<iterator> >(); |
| BOOST_MPL_ASSERT((boost::is_same<T, iterator_value_type>)); |
| BOOST_MPL_ASSERT((boost::is_convertible<iterator, const_iterator>)); |
| |
| // const_iterator |
| |
| boost::function_requires<boost::InputIteratorConcept<const_iterator> >(); |
| BOOST_MPL_ASSERT((boost::is_same<T, const_iterator_value_type>)); |
| |
| // difference_type |
| |
| BOOST_MPL_ASSERT((boost::mpl::bool_< |
| std::numeric_limits<difference_type>::is_signed>)); |
| BOOST_MPL_ASSERT((boost::mpl::bool_< |
| std::numeric_limits<difference_type>::is_integer>)); |
| BOOST_MPL_ASSERT((boost::is_same<difference_type, |
| iterator_difference_type>)); |
| BOOST_MPL_ASSERT((boost::is_same<difference_type, |
| const_iterator_difference_type>)); |
| |
| // size_type |
| |
| BOOST_MPL_ASSERT_NOT((boost::mpl::bool_< |
| std::numeric_limits<size_type>::is_signed>)); |
| BOOST_MPL_ASSERT((boost::mpl::bool_< |
| std::numeric_limits<size_type>::is_integer>)); |
| |
| // size_type can represent any non-negative value type of difference_type |
| // I'm not sure about either of these tests... |
| size_type max_diff((std::numeric_limits<difference_type>::max)()); |
| difference_type converted_diff(max_diff); |
| BOOST_TEST((std::numeric_limits<difference_type>::max)() |
| == converted_diff); |
| |
| BOOST_TEST( |
| static_cast<comparison_type>( |
| (std::numeric_limits<size_type>::max)()) > |
| static_cast<comparison_type>( |
| (std::numeric_limits<difference_type>::max)())); |
| |
| // I don't test the runtime post-conditions here. |
| X u; |
| BOOST_TEST(u.size() == 0); |
| BOOST_TEST(X().size() == 0); |
| |
| X a,b; |
| |
| sink(X(a)); |
| X u2(a); |
| X u3 = a; |
| |
| X* ptr = new X(); |
| X& a1 = *ptr; |
| (&a1)->~X(); |
| |
| X const a_const; |
| test::check_return_type<iterator>::equals(a.begin()); |
| test::check_return_type<const_iterator>::equals(a_const.begin()); |
| test::check_return_type<const_iterator>::equals(a.cbegin()); |
| test::check_return_type<const_iterator>::equals(a_const.cbegin()); |
| test::check_return_type<iterator>::equals(a.end()); |
| test::check_return_type<const_iterator>::equals(a_const.end()); |
| test::check_return_type<const_iterator>::equals(a.cend()); |
| test::check_return_type<const_iterator>::equals(a_const.cend()); |
| |
| a.swap(b); |
| test::check_return_type<X>::equals_ref(r = a); |
| test::check_return_type<size_type>::equals(a.size()); |
| test::check_return_type<size_type>::equals(a.max_size()); |
| test::check_return_type<bool>::convertible(a.empty()); |
| |
| // Allocator |
| |
| typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type; |
| test::check_return_type<allocator_type>::equals(a_const.get_allocator()); |
| |
| // Avoid unused variable warnings: |
| |
| sink(u); |
| sink(u2); |
| sink(u3); |
| } |
| |
| template <class X, class Key> |
| void unordered_set_test(X&, Key const&) |
| { |
| typedef BOOST_DEDUCED_TYPENAME X::value_type value_type; |
| typedef BOOST_DEDUCED_TYPENAME X::key_type key_type; |
| |
| BOOST_MPL_ASSERT((boost::is_same<value_type, key_type>)); |
| } |
| |
| template <class X, class Key, class T> |
| void unordered_map_test(X& r, Key const& k, T const& v) |
| { |
| typedef BOOST_DEDUCED_TYPENAME X::value_type value_type; |
| typedef BOOST_DEDUCED_TYPENAME X::key_type key_type; |
| BOOST_MPL_ASSERT(( |
| boost::is_same<value_type, std::pair<key_type const, T> >)); |
| |
| r.insert(std::pair<Key const, T>(k, v)); |
| |
| Key k_lvalue(k); |
| T v_lvalue(v); |
| |
| r.emplace(k, v); |
| r.emplace(k_lvalue, v_lvalue); |
| r.emplace(rvalue(k), rvalue(v)); |
| } |
| |
| template <class X> |
| void equality_test(X& r) |
| { |
| X const a = r, b = r; |
| |
| test::check_return_type<bool>::equals(a == b); |
| test::check_return_type<bool>::equals(a != b); |
| } |
| |
| template <class X, class T> |
| void unordered_unique_test(X& r, T const& t) |
| { |
| typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; |
| test::check_return_type<std::pair<iterator, bool> >::equals(r.insert(t)); |
| test::check_return_type<std::pair<iterator, bool> >::equals(r.emplace(t)); |
| } |
| |
| template <class X, class T> |
| void unordered_equivalent_test(X& r, T const& t) |
| { |
| typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; |
| test::check_return_type<iterator>::equals(r.insert(t)); |
| test::check_return_type<iterator>::equals(r.emplace(t)); |
| } |
| |
| template <class X, class Key, class T> |
| void unordered_map_functions(X&, Key const& k, T const&) |
| { |
| typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type; |
| |
| X a; |
| test::check_return_type<mapped_type>::equals_ref(a[k]); |
| test::check_return_type<mapped_type>::equals_ref(a.at(k)); |
| |
| X const b = a; |
| test::check_return_type<mapped_type const>::equals_ref(b.at(k)); |
| } |
| |
| template <class X, class Key, class T, class Hash, class Pred> |
| void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq) |
| { |
| typedef BOOST_DEDUCED_TYPENAME X::key_type key_type; |
| typedef BOOST_DEDUCED_TYPENAME X::hasher hasher; |
| typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal; |
| typedef BOOST_DEDUCED_TYPENAME X::size_type size_type; |
| |
| typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; |
| typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator; |
| typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator; |
| typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::BOOST_ITERATOR_CATEGORY<iterator>::type |
| iterator_category; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_difference<iterator>::type |
| iterator_difference; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_pointer<iterator>::type |
| iterator_pointer; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_reference<iterator>::type |
| iterator_reference; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::BOOST_ITERATOR_CATEGORY<local_iterator>::type |
| local_iterator_category; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_difference<local_iterator>::type |
| local_iterator_difference; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_pointer<local_iterator>::type |
| local_iterator_pointer; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_reference<local_iterator>::type |
| local_iterator_reference; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::BOOST_ITERATOR_CATEGORY<const_iterator>::type |
| const_iterator_category; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_difference<const_iterator>::type |
| const_iterator_difference; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_pointer<const_iterator>::type |
| const_iterator_pointer; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_reference<const_iterator>::type |
| const_iterator_reference; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::BOOST_ITERATOR_CATEGORY<const_local_iterator>::type |
| const_local_iterator_category; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_difference<const_local_iterator>::type |
| const_local_iterator_difference; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_pointer<const_local_iterator>::type |
| const_local_iterator_pointer; |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::iterator_reference<const_local_iterator>::type |
| const_local_iterator_reference; |
| |
| BOOST_MPL_ASSERT((boost::is_same<Key, key_type>)); |
| boost::function_requires<boost::CopyConstructibleConcept<key_type> >(); |
| boost::function_requires<boost::AssignableConcept<key_type> >(); |
| |
| BOOST_MPL_ASSERT((boost::is_same<Hash, hasher>)); |
| test::check_return_type<std::size_t>::equals(hf(k)); |
| |
| BOOST_MPL_ASSERT((boost::is_same<Pred, key_equal>)); |
| test::check_return_type<bool>::convertible(eq(k, k)); |
| |
| boost::function_requires<boost::InputIteratorConcept<local_iterator> >(); |
| BOOST_MPL_ASSERT((boost::is_same<local_iterator_category, |
| iterator_category>)); |
| BOOST_MPL_ASSERT((boost::is_same<local_iterator_difference, |
| iterator_difference>)); |
| BOOST_MPL_ASSERT((boost::is_same<local_iterator_pointer, |
| iterator_pointer>)); |
| BOOST_MPL_ASSERT((boost::is_same<local_iterator_reference, |
| iterator_reference>)); |
| |
| boost::function_requires< |
| boost::InputIteratorConcept<const_local_iterator> >(); |
| BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_category, |
| const_iterator_category>)); |
| BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_difference, |
| const_iterator_difference>)); |
| BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_pointer, |
| const_iterator_pointer>)); |
| BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_reference, |
| const_iterator_reference>)); |
| |
| X(10, hf, eq); |
| X a(10, hf, eq); |
| X(10, hf); |
| X a2(10, hf); |
| X(10); |
| X a3(10); |
| X(); |
| X a4; |
| |
| BOOST_DEDUCED_TYPENAME X::value_type* i = 0; |
| BOOST_DEDUCED_TYPENAME X::value_type* j = 0; |
| |
| X(i, j, 10, hf, eq); |
| X a5(i, j, 10, hf, eq); |
| X(i, j, 10, hf); |
| X a6(i, j, 10, hf); |
| X(i, j, 10); |
| X a7(i, j, 10); |
| X(i, j); |
| X a8(i, j); |
| |
| X const b; |
| sink(X(b)); |
| X a9(b); |
| a = b; |
| |
| test::check_return_type<hasher>::equals(b.hash_function()); |
| test::check_return_type<key_equal>::equals(b.key_eq()); |
| |
| const_iterator q = a.cbegin(); |
| test::check_return_type<iterator>::equals(a.insert(q, t)); |
| test::check_return_type<iterator>::equals(a.emplace_hint(q, t)); |
| |
| a.insert(i, j); |
| test::check_return_type<size_type>::equals(a.erase(k)); |
| |
| BOOST_TEST(a.empty()); |
| if(a.empty()) { |
| a.insert(t); |
| q = a.cbegin(); |
| test::check_return_type<iterator>::equals(a.erase(q)); |
| } |
| |
| const_iterator q1 = a.cbegin(), q2 = a.cend(); |
| test::check_return_type<iterator>::equals(a.erase(q1, q2)); |
| |
| a.clear(); |
| |
| test::check_return_type<iterator>::equals(a.find(k)); |
| test::check_return_type<const_iterator>::equals(b.find(k)); |
| test::check_return_type<size_type>::equals(b.count(k)); |
| test::check_return_type<std::pair<iterator, iterator> >::equals( |
| a.equal_range(k)); |
| test::check_return_type<std::pair<const_iterator, const_iterator> >::equals( |
| b.equal_range(k)); |
| test::check_return_type<size_type>::equals(b.bucket_count()); |
| test::check_return_type<size_type>::equals(b.max_bucket_count()); |
| test::check_return_type<size_type>::equals(b.bucket(k)); |
| test::check_return_type<size_type>::equals(b.bucket_size(0)); |
| |
| test::check_return_type<local_iterator>::equals(a.begin(0)); |
| test::check_return_type<const_local_iterator>::equals(b.begin(0)); |
| test::check_return_type<local_iterator>::equals(a.end(0)); |
| test::check_return_type<const_local_iterator>::equals(b.end(0)); |
| |
| test::check_return_type<const_local_iterator>::equals(a.cbegin(0)); |
| test::check_return_type<const_local_iterator>::equals(b.cbegin(0)); |
| test::check_return_type<const_local_iterator>::equals(a.cend(0)); |
| test::check_return_type<const_local_iterator>::equals(b.cend(0)); |
| |
| test::check_return_type<float>::equals(b.load_factor()); |
| test::check_return_type<float>::equals(b.max_load_factor()); |
| a.max_load_factor((float) 2.0); |
| a.rehash(100); |
| |
| // Avoid unused variable warnings: |
| |
| sink(a); |
| sink(a2); |
| sink(a3); |
| sink(a4); |
| sink(a5); |
| sink(a6); |
| sink(a7); |
| sink(a8); |
| sink(a9); |
| } |