Combine the 'container' and 'unordered' tests.

[SVN r42531]

test/unordered/Jamfile.v2

@@ -14,8 +14,12 @@ project unordered-test/unordered
 
 test-suite unordered-tests
     :
-        [ run equivalent_keys_tests.cpp ]
+        [ run set_compile.cpp ]
+        [ run map_compile.cpp ]
+        [ run simple_tests.cpp ]
+        [ run link_test_1.cpp link_test_2.cpp ]
         [ run compile_tests.cpp ]
+        [ run equivalent_keys_tests.cpp ]
         [ run constructor_tests.cpp ]
         [ run copy_tests.cpp ]
         [ run assign_tests.cpp ]

test/unordered/compile_tests.hpp

@@ -0,0 +1,130 @@
+
+// Copyright 2005-2007 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
+#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 X, class T>
+void container_test(X& r, T&)
+{
+    typedef typename X::iterator iterator;
+    typedef typename X::const_iterator const_iterator;
+    typedef typename X::difference_type difference_type;
+    typedef typename X::size_type size_type;
+
+    typedef typename boost::iterator_value<iterator>::type iterator_value_type;
+    typedef typename boost::iterator_value<const_iterator>::type const_iterator_value_type;
+    typedef typename boost::iterator_difference<iterator>::type iterator_difference_type;
+    typedef typename boost::iterator_difference<const_iterator>::type const_iterator_difference_type;
+
+    typedef typename X::value_type value_type;
+    typedef typename X::reference reference;
+    typedef 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());
+
+    // No tests for ==, != since they're not required for unordered containers.
+
+    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());
+}

test/unordered/link_test_1.cpp

@@ -0,0 +1,24 @@
+
+// Copyright 2006-2007 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)
+
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+
+void foo(boost::unordered_set<int>&,
+        boost::unordered_map<int, int>&,
+        boost::unordered_multiset<int>&,
+        boost::unordered_multimap<int, int>&);
+
+int main()
+{
+    boost::unordered_set<int> x1;
+    boost::unordered_map<int, int> x2;
+    boost::unordered_multiset<int> x3;
+    boost::unordered_multimap<int, int> x4;
+
+    foo(x1, x2, x3, x4);
+    
+    return 0;
+}

test/unordered/link_test_2.cpp

@@ -0,0 +1,18 @@
+
+// Copyright 2006-2007 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)
+
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+
+void foo(boost::unordered_set<int>& x1,
+        boost::unordered_map<int, int>& x2,
+        boost::unordered_multiset<int>& x3,
+        boost::unordered_multimap<int, int>& x4)
+{
+    x1.insert(1);
+    x2[2] = 2;
+    x3.insert(3);
+    x4.insert(std::make_pair(4, 5));
+}

test/unordered/map_compile.cpp

@@ -0,0 +1,45 @@
+
+// Copyright 2006-2007 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)
+
+// This test creates the containers with members that meet their minimum
+// requirements. Makes sure everything compiles and is defined correctly.
+
+#include <boost/unordered_map.hpp>
+
+#include <iostream>
+#include <boost/detail/lightweight_test.hpp>
+#include "../objects/minimal.hpp"
+#include "./compile_tests.hpp"
+
+int main()
+{
+    typedef std::pair<test::minimal::assignable const,
+            test::minimal::copy_constructible> value_type;
+    value_type value(
+            test::minimal::assignable::create(),
+            test::minimal::copy_constructible::create());
+
+    std::cout<<"Test unordered_map.\n";
+    boost::unordered_map<
+        test::minimal::assignable,
+        test::minimal::copy_constructible,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<value_type> > map;
+
+    container_test(map, value);
+
+    std::cout<<"Test unordered_multimap.\n";
+    boost::unordered_multimap<
+        test::minimal::assignable,
+        test::minimal::copy_constructible,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<value_type> > multimap;
+
+    container_test(multimap, value);
+
+    return boost::report_errors();
+}

test/unordered/set_compile.cpp

@@ -0,0 +1,39 @@
+
+// Copyright 2006-2007 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)
+
+// This test creates the containers with members that meet their minimum
+// requirements. Makes sure everything compiles and is defined correctly.
+
+#include <boost/unordered_set.hpp>
+
+#include <iostream>
+#include <boost/detail/lightweight_test.hpp>
+#include "../objects/minimal.hpp"
+#include "./compile_tests.hpp"
+
+int main()
+{
+    test::minimal::assignable assignable = test::minimal::assignable::create();
+
+    std::cout<<"Test unordered_set.\n";
+    boost::unordered_set<
+        test::minimal::assignable,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<test::minimal::assignable> > set;
+
+    container_test(set, assignable);
+
+    std::cout<<"Test unordered_multiset.\n";
+    boost::unordered_multiset<
+        test::minimal::assignable,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<test::minimal::assignable> > multiset;
+
+    container_test(multiset, assignable);
+
+    return boost::report_errors();
+}

test/unordered/simple_tests.cpp

@@ -0,0 +1,104 @@
+
+// Copyright 2006-2007 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)
+
+// This test checks the runtime requirements of containers.
+
+#include <boost/unordered_set.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <algorithm>
+#include "../helpers/equivalent.hpp"
+
+template <class X>
+void simple_test(X const& a)
+{
+    test::unordered_equivalence_tester<X> equivalent(a);
+
+    {
+        X u;
+        BOOST_TEST(u.size() == 0);
+        BOOST_TEST(X().size() == 0);
+    }
+
+    {
+        BOOST_TEST(equivalent(X(a)));
+    }
+
+    {
+        X u(a);
+        BOOST_TEST(equivalent(u));
+    }
+
+    {
+        X u = a;
+        BOOST_TEST(equivalent(u));
+    }
+
+    {
+        X b(a);
+        BOOST_TEST(b.begin() == const_cast<X const&>(b).cbegin());
+        BOOST_TEST(b.end() == const_cast<X const&>(b).cend());
+    }
+
+    {
+        X b(a);
+        X c;
+        BOOST_TEST(equivalent(b));
+        BOOST_TEST(c.empty());
+        b.swap(c);
+        BOOST_TEST(b.empty());
+        BOOST_TEST(equivalent(c));
+        b.swap(c);
+        BOOST_TEST(b.empty());
+        BOOST_TEST(equivalent(c));
+    }
+
+    {
+        X u;
+        X& r = u;
+        BOOST_TEST(&(r = r) == &r);
+        BOOST_TEST(r.empty());
+        BOOST_TEST(&(r = a) == &r);
+        BOOST_TEST(equivalent(r));
+        BOOST_TEST(&(r = r) == &r);
+        BOOST_TEST(equivalent(r));
+    }
+
+    {
+        BOOST_TEST(a.size() ==
+                (typename X::size_type) std::distance(a.begin(), a.end()));
+    }
+
+    {
+        BOOST_TEST(a.empty() == (a.size() == 0));
+    }
+
+    {
+        BOOST_TEST(a.empty() == (a.begin() == a.end()));
+        X u;
+        BOOST_TEST(u.begin() == u.end());
+    }
+}
+
+int main()
+{
+    std::cout<<"Test unordered_set.\n";
+    boost::unordered_set<int> set;
+    simple_test(set);
+
+    std::cout<<"Test unordered_multiset.\n";
+    boost::unordered_multiset<int> multiset;
+    simple_test(multiset);
+    
+    std::cout<<"Test unordered_map.\n";
+    boost::unordered_map<int, int> map;
+    simple_test(map);
+
+    std::cout<<"Test unordered_multimap.\n";
+    boost::unordered_multimap<int, int> multimap;
+    simple_test(multimap);
+
+    return boost::report_errors();
+}