[ceph.git] / ceph / src / boost / libs / unordered / test / unordered / constructor_tests.cpp


// Copyright 2006-2010 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)

// clang-format off
#include "../helpers/prefix.hpp"
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
#include "../helpers/postfix.hpp"
// clang-format on

#include "../helpers/test.hpp"
#include "../objects/test.hpp"
#include "../helpers/random_values.hpp"
#include "../helpers/tracker.hpp"
#include "../helpers/equivalent.hpp"
#include "../helpers/input_iterator.hpp"
#include "../helpers/invariants.hpp"

namespace constructor_tests {

  test::seed_t initialize_seed(356730);

  template <class T>
  void constructor_tests1(T*, test::random_generator generator)
  {
    BOOST_DEDUCED_TYPENAME T::hasher hf;
    BOOST_DEDUCED_TYPENAME T::key_equal eq;
    BOOST_DEDUCED_TYPENAME T::allocator_type al;

    UNORDERED_SUB_TEST("Construct 1")
    {
      test::check_instances check_;

      T x(0, hf, eq);
      BOOST_TEST(x.empty());
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 2")
    {
      test::check_instances check_;

      T x(100, hf);
      BOOST_TEST(x.empty());
      BOOST_TEST(x.bucket_count() >= 100);
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 3")
    {
      test::check_instances check_;

      T x(2000);
      BOOST_TEST(x.empty());
      BOOST_TEST(x.bucket_count() >= 2000);
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 4")
    {
      test::check_instances check_;

      T x;
      BOOST_TEST(x.empty());
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 5")
    {
      test::check_instances check_;

      test::random_values<T> v(1000, generator);
      T x(v.begin(), v.end(), 10000, hf, eq);
      BOOST_TEST(x.bucket_count() >= 10000);
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_container(x, v);
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 6")
    {
      test::check_instances check_;

      test::random_values<T> v(10, generator);
      T x(v.begin(), v.end(), 10000, hf);
      BOOST_TEST(x.bucket_count() >= 10000);
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_container(x, v);
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 7")
    {
      test::check_instances check_;

      test::random_values<T> v(100, generator);
      T x(v.begin(), v.end(), 100);
      BOOST_TEST(x.bucket_count() >= 100);
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_container(x, v);
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 8")
    {
      test::check_instances check_;

      test::random_values<T> v(1, generator);
      T x(v.begin(), v.end());
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_container(x, v);
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 9")
    {
      test::check_instances check_;

      T x(0, hf, eq, al);
      BOOST_TEST(x.empty());
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 10")
    {
      test::check_instances check_;

      test::random_values<T> v(1000, generator);
      T x(v.begin(), v.end(), 10000, hf, eq, al);
      BOOST_TEST(x.bucket_count() >= 10000);
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_container(x, v);
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 11")
    {
      test::check_instances check_;

      T x(al);
      BOOST_TEST(x.empty());
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_equivalent_keys(x);
    }
  }

  template <class T>
  void constructor_tests2(T*, test::random_generator const& generator)
  {
    BOOST_DEDUCED_TYPENAME T::hasher hf;
    BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
    BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
    BOOST_DEDUCED_TYPENAME T::key_equal eq;
    BOOST_DEDUCED_TYPENAME T::key_equal eq1(1);
    BOOST_DEDUCED_TYPENAME T::key_equal eq2(2);
    BOOST_DEDUCED_TYPENAME T::allocator_type al;
    BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
    BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);

    UNORDERED_SUB_TEST("Construct 1")
    {
      test::check_instances check_;
      T x(10000, hf1, eq1);
      BOOST_TEST(x.bucket_count() >= 10000);
      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 2")
    {
      test::check_instances check_;
      T x(100, hf1);
      BOOST_TEST(x.empty());
      BOOST_TEST(x.bucket_count() >= 100);
      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 3")
    {
      test::check_instances check_;
      test::random_values<T> v(100, generator);
      T x(v.begin(), v.end(), 0, hf1, eq1);
      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_container(x, v);
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 4")
    {
      test::check_instances check_;
      test::random_values<T> v(5, generator);
      T x(v.begin(), v.end(), 1000, hf1);
      BOOST_TEST(x.bucket_count() >= 1000);
      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
      test::check_container(x, v);
      test::check_equivalent_keys(x);
    }

    UNORDERED_SUB_TEST("Construct 5")
    {
      test::check_instances check_;
      test::random_values<T> v(100, generator);
      T x(v.begin(), v.end(), 0, hf, eq, al1);
      T y(x.begin(), x.end(), 0, hf1, eq1, al2);
      test::check_container(x, v);
      test::check_container(y, x);
      test::check_equivalent_keys(x);
      test::check_equivalent_keys(y);
    }

    UNORDERED_SUB_TEST("Construct 6")
    {
      test::check_instances check_;
      test::random_values<T> v(100, generator);
      T x(v.begin(), v.end(), 0, hf1, eq1);
      T y(x.begin(), x.end(), 0, hf, eq);
      test::check_container(x, v);
      test::check_container(y, x);
      test::check_equivalent_keys(x);
      test::check_equivalent_keys(y);
    }

    UNORDERED_SUB_TEST("Construct 7")
    {
      test::check_instances check_;
      test::random_values<T> v(100, generator);
      T x(v.begin(), v.end(), 0, hf1, eq1);
      T y(x.begin(), x.end(), 0, hf2, eq2);
      test::check_container(x, v);
      test::check_container(y, x);
      test::check_equivalent_keys(x);
      test::check_equivalent_keys(y);
    }

    UNORDERED_SUB_TEST("Construct 8 - from input iterator")
    {
      test::check_instances check_;
      test::random_values<T> v(100, generator);
      BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator v_begin =
                                                                      v.begin(),
                                                                    v_end =
                                                                      v.end();
      T x(test::input_iterator(v_begin), test::input_iterator(v_end), 0, hf1,
        eq1);
      BOOST_DEDUCED_TYPENAME T::const_iterator x_begin = x.begin(),
                                               x_end = x.end();
      T y(test::input_iterator(x_begin), test::input_iterator(x_end), 0, hf2,
        eq2);
      test::check_container(x, v);
      test::check_container(y, x);
      test::check_equivalent_keys(x);
      test::check_equivalent_keys(y);
    }

    UNORDERED_SUB_TEST("Construct 8.5 - from copy iterator")
    {
      test::check_instances check_;
      test::random_values<T> v(100, generator);
      T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0, hf1,
        eq1);
      T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0, hf2,
        eq2);
      test::check_container(x, v);
      test::check_container(y, x);
      test::check_equivalent_keys(x);
      test::check_equivalent_keys(y);
    }

    UNORDERED_SUB_TEST("Construct 9")
    {
      test::check_instances check_;

      test::random_values<T> v(100, generator);
      T x(50);
      BOOST_TEST(x.bucket_count() >= 50);
      x.max_load_factor(10);
      BOOST_TEST(x.bucket_count() >= 50);
      x.insert(v.begin(), v.end());
      BOOST_TEST(x.bucket_count() >= 50);
      test::check_container(x, v);
      test::check_equivalent_keys(x);
    }

#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;

    UNORDERED_SUB_TEST("Initializer list construct 1")
    {
      test::check_instances check_;

      T x(list);
      BOOST_TEST(x.empty());
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
    }

    UNORDERED_SUB_TEST("Initializer list construct 2")
    {
      test::check_instances check_;

      T x(list, 1000);
      BOOST_TEST(x.empty());
      BOOST_TEST(x.bucket_count() >= 1000);
      BOOST_TEST(test::equivalent(x.hash_function(), hf));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
    }

    UNORDERED_SUB_TEST("Initializer list construct 3")
    {
      test::check_instances check_;

      T x(list, 10, hf1);
      BOOST_TEST(x.empty());
      BOOST_TEST(x.bucket_count() >= 10);
      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
      BOOST_TEST(test::equivalent(x.key_eq(), eq));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
    }

    UNORDERED_SUB_TEST("Initializer list construct 4")
    {
      test::check_instances check_;

      T x(list, 10, hf1, eq1);
      BOOST_TEST(x.empty());
      BOOST_TEST(x.bucket_count() >= 10);
      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
      BOOST_TEST(test::equivalent(x.get_allocator(), al));
    }

    UNORDERED_SUB_TEST("Initializer list construct 5")
    {
      test::check_instances check_;

      T x(list, 10, hf1, eq1, al1);
      BOOST_TEST(x.empty());
      BOOST_TEST(x.bucket_count() >= 10);
      BOOST_TEST(test::equivalent(x.hash_function(), hf1));
      BOOST_TEST(test::equivalent(x.key_eq(), eq1));
      BOOST_TEST(test::equivalent(x.get_allocator(), al1));
    }
#endif
  }

  template <class T>
  void map_constructor_test(T*, test::random_generator const& generator)
  {
    typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type,
      BOOST_DEDUCED_TYPENAME T::mapped_type> >
      list;
    test::random_values<T> v(1000, generator);
    list l(v.begin(), v.end());
    T x(l.begin(), l.end());

    test::check_container(x, v);
    test::check_equivalent_keys(x);
  }

  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
    std::allocator<test::object> >* test_map_std_alloc;

  boost::unordered_set<test::object, test::hash, test::equal_to,
    test::allocator1<test::object> >* test_set;
  boost::unordered_multiset<test::object, test::hash, test::equal_to,
    test::allocator2<test::object> >* test_multiset;
  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
    test::allocator2<test::object> >* test_map;
  boost::unordered_multimap<test::object, test::object, test::hash,
    test::equal_to, test::allocator1<test::object> >* test_multimap;

  using test::default_generator;
  using test::generate_collisions;
  using test::limited_range;

  UNORDERED_TEST(constructor_tests1,
    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))(
      (default_generator)(generate_collisions)(limited_range)))

  UNORDERED_TEST(constructor_tests2,
    ((test_set)(test_multiset)(test_map)(test_multimap))(
      (default_generator)(generate_collisions)(limited_range)))

  UNORDERED_TEST(map_constructor_test,
    ((test_map_std_alloc)(test_map)(test_multimap))(
      (default_generator)(generate_collisions)(limited_range)))

#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

  UNORDERED_AUTO_TEST (test_default_initializer_list) {
    std::initializer_list<int> init;
    boost::unordered_set<int> x1 = init;
    BOOST_TEST(x1.empty());
  }

#endif

#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)

  UNORDERED_AUTO_TEST (test_initializer_list) {
    boost::unordered_set<int> x1 = {2, 10, 45, -5};
    BOOST_TEST(x1.find(10) != x1.end());
    BOOST_TEST(x1.find(46) == x1.end());
  }

#endif
}

RUN_TESTS_QUIET()
Commit	Line	Data
7c673cae FG	1
	2	// Copyright 2006-2010 Daniel James.
	3	// Distributed under the Boost Software License, Version 1.0. (See accompanying
	4	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	5
b32b8144	6	// clang-format off
7c673cae FG	7	#include "../helpers/prefix.hpp"
	8	#include <boost/unordered_set.hpp>
	9	#include <boost/unordered_map.hpp>
	10	#include "../helpers/postfix.hpp"
b32b8144	11	// clang-format on
7c673cae FG	12
	13	#include "../helpers/test.hpp"
	14	#include "../objects/test.hpp"
	15	#include "../helpers/random_values.hpp"
	16	#include "../helpers/tracker.hpp"
	17	#include "../helpers/equivalent.hpp"
	18	#include "../helpers/input_iterator.hpp"
	19	#include "../helpers/invariants.hpp"
	20
	21	namespace constructor_tests {
	22
b32b8144	23	test::seed_t initialize_seed(356730);
7c673cae	24
b32b8144 FG	25	template <class T>
	26	void constructor_tests1(T*, test::random_generator generator)
	27	{
7c673cae FG	28	BOOST_DEDUCED_TYPENAME T::hasher hf;
	29	BOOST_DEDUCED_TYPENAME T::key_equal eq;
	30	BOOST_DEDUCED_TYPENAME T::allocator_type al;
	31
b32b8144	32	UNORDERED_SUB_TEST("Construct 1")
7c673cae	33	{
b32b8144 FG	34	test::check_instances check_;
	35
	36	T x(0, hf, eq);
	37	BOOST_TEST(x.empty());
	38	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	39	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	40	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	41	test::check_equivalent_keys(x);
7c673cae FG	42	}
7c673cae FG	43
b32b8144	44	UNORDERED_SUB_TEST("Construct 2")
7c673cae	45	{
b32b8144 FG	46	test::check_instances check_;
	47
	48	T x(100, hf);
	49	BOOST_TEST(x.empty());
	50	BOOST_TEST(x.bucket_count() >= 100);
	51	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	52	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	53	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	54	test::check_equivalent_keys(x);
7c673cae FG	55	}
7c673cae FG	56
b32b8144	57	UNORDERED_SUB_TEST("Construct 3")
7c673cae	58	{
b32b8144 FG	59	test::check_instances check_;
	60
	61	T x(2000);
	62	BOOST_TEST(x.empty());
	63	BOOST_TEST(x.bucket_count() >= 2000);
	64	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	65	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	66	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	67	test::check_equivalent_keys(x);
7c673cae FG	68	}
7c673cae FG	69
b32b8144	70	UNORDERED_SUB_TEST("Construct 4")
7c673cae	71	{
b32b8144 FG	72	test::check_instances check_;
	73
	74	T x;
	75	BOOST_TEST(x.empty());
	76	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	77	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	78	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	79	test::check_equivalent_keys(x);
7c673cae FG	80	}
7c673cae FG	81
b32b8144	82	UNORDERED_SUB_TEST("Construct 5")
7c673cae	83	{
b32b8144 FG	84	test::check_instances check_;
	85
	86	test::random_values<T> v(1000, generator);
	87	T x(v.begin(), v.end(), 10000, hf, eq);
	88	BOOST_TEST(x.bucket_count() >= 10000);
	89	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	90	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	91	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	92	test::check_container(x, v);
	93	test::check_equivalent_keys(x);
7c673cae FG	94	}
7c673cae FG	95
b32b8144	96	UNORDERED_SUB_TEST("Construct 6")
7c673cae	97	{
b32b8144 FG	98	test::check_instances check_;
	99
	100	test::random_values<T> v(10, generator);
	101	T x(v.begin(), v.end(), 10000, hf);
	102	BOOST_TEST(x.bucket_count() >= 10000);
	103	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	104	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	105	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	106	test::check_container(x, v);
	107	test::check_equivalent_keys(x);
7c673cae FG	108	}
7c673cae FG	109
b32b8144	110	UNORDERED_SUB_TEST("Construct 7")
7c673cae	111	{
b32b8144 FG	112	test::check_instances check_;
	113
	114	test::random_values<T> v(100, generator);
	115	T x(v.begin(), v.end(), 100);
	116	BOOST_TEST(x.bucket_count() >= 100);
	117	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	118	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	119	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	120	test::check_container(x, v);
	121	test::check_equivalent_keys(x);
7c673cae FG	122	}
7c673cae FG	123
b32b8144	124	UNORDERED_SUB_TEST("Construct 8")
7c673cae	125	{
b32b8144 FG	126	test::check_instances check_;
	127
	128	test::random_values<T> v(1, generator);
	129	T x(v.begin(), v.end());
	130	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	131	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	132	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	133	test::check_container(x, v);
	134	test::check_equivalent_keys(x);
7c673cae FG	135	}
7c673cae FG	136
b32b8144	137	UNORDERED_SUB_TEST("Construct 9")
7c673cae	138	{
b32b8144 FG	139	test::check_instances check_;
	140
	141	T x(0, hf, eq, al);
	142	BOOST_TEST(x.empty());
	143	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	144	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	145	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	146	test::check_equivalent_keys(x);
7c673cae FG	147	}
7c673cae FG	148
b32b8144	149	UNORDERED_SUB_TEST("Construct 10")
7c673cae	150	{
b32b8144 FG	151	test::check_instances check_;
	152
	153	test::random_values<T> v(1000, generator);
	154	T x(v.begin(), v.end(), 10000, hf, eq, al);
	155	BOOST_TEST(x.bucket_count() >= 10000);
	156	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	157	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	158	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	159	test::check_container(x, v);
	160	test::check_equivalent_keys(x);
7c673cae FG	161	}
7c673cae FG	162
b32b8144	163	UNORDERED_SUB_TEST("Construct 11")
7c673cae	164	{
b32b8144 FG	165	test::check_instances check_;
	166
	167	T x(al);
	168	BOOST_TEST(x.empty());
	169	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	170	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	171	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	172	test::check_equivalent_keys(x);
7c673cae	173	}
b32b8144	174	}
7c673cae	175
b32b8144 FG	176	template <class T>
	177	void constructor_tests2(T*, test::random_generator const& generator)
	178	{
7c673cae FG	179	BOOST_DEDUCED_TYPENAME T::hasher hf;
	180	BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
	181	BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
	182	BOOST_DEDUCED_TYPENAME T::key_equal eq;
	183	BOOST_DEDUCED_TYPENAME T::key_equal eq1(1);
	184	BOOST_DEDUCED_TYPENAME T::key_equal eq2(2);
	185	BOOST_DEDUCED_TYPENAME T::allocator_type al;
	186	BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
	187	BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
	188
b32b8144	189	UNORDERED_SUB_TEST("Construct 1")
7c673cae	190	{
b32b8144 FG	191	test::check_instances check_;
	192	T x(10000, hf1, eq1);
	193	BOOST_TEST(x.bucket_count() >= 10000);
	194	BOOST_TEST(test::equivalent(x.hash_function(), hf1));
	195	BOOST_TEST(test::equivalent(x.key_eq(), eq1));
	196	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	197	test::check_equivalent_keys(x);
7c673cae FG	198	}
7c673cae FG	199
b32b8144	200	UNORDERED_SUB_TEST("Construct 2")
7c673cae	201	{
b32b8144 FG	202	test::check_instances check_;
	203	T x(100, hf1);
	204	BOOST_TEST(x.empty());
	205	BOOST_TEST(x.bucket_count() >= 100);
	206	BOOST_TEST(test::equivalent(x.hash_function(), hf1));
	207	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	208	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	209	test::check_equivalent_keys(x);
7c673cae FG	210	}
7c673cae FG	211
b32b8144	212	UNORDERED_SUB_TEST("Construct 3")
7c673cae	213	{
b32b8144 FG	214	test::check_instances check_;
	215	test::random_values<T> v(100, generator);
	216	T x(v.begin(), v.end(), 0, hf1, eq1);
	217	BOOST_TEST(test::equivalent(x.hash_function(), hf1));
	218	BOOST_TEST(test::equivalent(x.key_eq(), eq1));
	219	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	220	test::check_container(x, v);
	221	test::check_equivalent_keys(x);
7c673cae FG	222	}
7c673cae FG	223
b32b8144	224	UNORDERED_SUB_TEST("Construct 4")
7c673cae	225	{
b32b8144 FG	226	test::check_instances check_;
	227	test::random_values<T> v(5, generator);
	228	T x(v.begin(), v.end(), 1000, hf1);
	229	BOOST_TEST(x.bucket_count() >= 1000);
	230	BOOST_TEST(test::equivalent(x.hash_function(), hf1));
	231	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	232	BOOST_TEST(test::equivalent(x.get_allocator(), al));
	233	test::check_container(x, v);
	234	test::check_equivalent_keys(x);
7c673cae FG	235	}
7c673cae FG	236
b32b8144	237	UNORDERED_SUB_TEST("Construct 5")
7c673cae	238	{
b32b8144 FG	239	test::check_instances check_;
	240	test::random_values<T> v(100, generator);
	241	T x(v.begin(), v.end(), 0, hf, eq, al1);
	242	T y(x.begin(), x.end(), 0, hf1, eq1, al2);
	243	test::check_container(x, v);
	244	test::check_container(y, x);
	245	test::check_equivalent_keys(x);
	246	test::check_equivalent_keys(y);
7c673cae FG	247	}
7c673cae FG	248
b32b8144	249	UNORDERED_SUB_TEST("Construct 6")
7c673cae	250	{
b32b8144 FG	251	test::check_instances check_;
	252	test::random_values<T> v(100, generator);
	253	T x(v.begin(), v.end(), 0, hf1, eq1);
	254	T y(x.begin(), x.end(), 0, hf, eq);
	255	test::check_container(x, v);
	256	test::check_container(y, x);
	257	test::check_equivalent_keys(x);
	258	test::check_equivalent_keys(y);
7c673cae FG	259	}
7c673cae FG	260
b32b8144	261	UNORDERED_SUB_TEST("Construct 7")
7c673cae	262	{
b32b8144 FG	263	test::check_instances check_;
	264	test::random_values<T> v(100, generator);
	265	T x(v.begin(), v.end(), 0, hf1, eq1);
	266	T y(x.begin(), x.end(), 0, hf2, eq2);
	267	test::check_container(x, v);
	268	test::check_container(y, x);
	269	test::check_equivalent_keys(x);
	270	test::check_equivalent_keys(y);
7c673cae FG	271	}
7c673cae FG	272
b32b8144	273	UNORDERED_SUB_TEST("Construct 8 - from input iterator")
7c673cae	274	{
b32b8144 FG	275	test::check_instances check_;
	276	test::random_values<T> v(100, generator);
	277	BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator v_begin =
	278	v.begin(),
	279	v_end =
	280	v.end();
	281	T x(test::input_iterator(v_begin), test::input_iterator(v_end), 0, hf1,
	282	eq1);
	283	BOOST_DEDUCED_TYPENAME T::const_iterator x_begin = x.begin(),
	284	x_end = x.end();
	285	T y(test::input_iterator(x_begin), test::input_iterator(x_end), 0, hf2,
	286	eq2);
	287	test::check_container(x, v);
	288	test::check_container(y, x);
	289	test::check_equivalent_keys(x);
	290	test::check_equivalent_keys(y);
7c673cae	291	}
b32b8144 FG	292
b32b8144 FG	293	UNORDERED_SUB_TEST("Construct 8.5 - from copy iterator")
7c673cae	294	{
b32b8144 FG	295	test::check_instances check_;
	296	test::random_values<T> v(100, generator);
	297	T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0, hf1,
	298	eq1);
	299	T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0, hf2,
	300	eq2);
	301	test::check_container(x, v);
	302	test::check_container(y, x);
	303	test::check_equivalent_keys(x);
	304	test::check_equivalent_keys(y);
7c673cae	305	}
b32b8144 FG	306
b32b8144 FG	307	UNORDERED_SUB_TEST("Construct 9")
7c673cae	308	{
b32b8144 FG	309	test::check_instances check_;
	310
	311	test::random_values<T> v(100, generator);
	312	T x(50);
	313	BOOST_TEST(x.bucket_count() >= 50);
	314	x.max_load_factor(10);
	315	BOOST_TEST(x.bucket_count() >= 50);
	316	x.insert(v.begin(), v.end());
	317	BOOST_TEST(x.bucket_count() >= 50);
	318	test::check_container(x, v);
	319	test::check_equivalent_keys(x);
7c673cae FG	320	}
	321
	322	#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
	323	std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
b32b8144 FG	324
b32b8144 FG	325	UNORDERED_SUB_TEST("Initializer list construct 1")
7c673cae	326	{
b32b8144	327	test::check_instances check_;
7c673cae	328
b32b8144 FG	329	T x(list);
	330	BOOST_TEST(x.empty());
	331	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	332	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	333	BOOST_TEST(test::equivalent(x.get_allocator(), al));
7c673cae FG	334	}
7c673cae FG	335
b32b8144	336	UNORDERED_SUB_TEST("Initializer list construct 2")
7c673cae	337	{
b32b8144 FG	338	test::check_instances check_;
	339
	340	T x(list, 1000);
	341	BOOST_TEST(x.empty());
	342	BOOST_TEST(x.bucket_count() >= 1000);
	343	BOOST_TEST(test::equivalent(x.hash_function(), hf));
	344	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	345	BOOST_TEST(test::equivalent(x.get_allocator(), al));
7c673cae FG	346	}
7c673cae FG	347
b32b8144	348	UNORDERED_SUB_TEST("Initializer list construct 3")
7c673cae	349	{
b32b8144 FG	350	test::check_instances check_;
	351
	352	T x(list, 10, hf1);
	353	BOOST_TEST(x.empty());
	354	BOOST_TEST(x.bucket_count() >= 10);
	355	BOOST_TEST(test::equivalent(x.hash_function(), hf1));
	356	BOOST_TEST(test::equivalent(x.key_eq(), eq));
	357	BOOST_TEST(test::equivalent(x.get_allocator(), al));
7c673cae FG	358	}
7c673cae FG	359
b32b8144	360	UNORDERED_SUB_TEST("Initializer list construct 4")
7c673cae	361	{
b32b8144 FG	362	test::check_instances check_;
	363
	364	T x(list, 10, hf1, eq1);
	365	BOOST_TEST(x.empty());
	366	BOOST_TEST(x.bucket_count() >= 10);
	367	BOOST_TEST(test::equivalent(x.hash_function(), hf1));
	368	BOOST_TEST(test::equivalent(x.key_eq(), eq1));
	369	BOOST_TEST(test::equivalent(x.get_allocator(), al));
7c673cae FG	370	}
7c673cae FG	371
b32b8144	372	UNORDERED_SUB_TEST("Initializer list construct 5")
7c673cae	373	{
b32b8144 FG	374	test::check_instances check_;
	375
	376	T x(list, 10, hf1, eq1, al1);
	377	BOOST_TEST(x.empty());
	378	BOOST_TEST(x.bucket_count() >= 10);
	379	BOOST_TEST(test::equivalent(x.hash_function(), hf1));
	380	BOOST_TEST(test::equivalent(x.key_eq(), eq1));
	381	BOOST_TEST(test::equivalent(x.get_allocator(), al1));
7c673cae FG	382	}
7c673cae FG	383	#endif
b32b8144 FG	384	}
	385
	386	template <class T>
	387	void map_constructor_test(T*, test::random_generator const& generator)
	388	{
	389	typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type,
	390	BOOST_DEDUCED_TYPENAME T::mapped_type> >
	391	list;
7c673cae FG	392	test::random_values<T> v(1000, generator);
	393	list l(v.begin(), v.end());
	394	T x(l.begin(), l.end());
	395
	396	test::check_container(x, v);
	397	test::check_equivalent_keys(x);
b32b8144	398	}
7c673cae	399
b32b8144	400	boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
7c673cae FG	401	std::allocator<test::object> >* test_map_std_alloc;
7c673cae FG	402
b32b8144	403	boost::unordered_set<test::object, test::hash, test::equal_to,
7c673cae	404	test::allocator1<test::object> >* test_set;
b32b8144	405	boost::unordered_multiset<test::object, test::hash, test::equal_to,
7c673cae	406	test::allocator2<test::object> >* test_multiset;
b32b8144	407	boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
7c673cae	408	test::allocator2<test::object> >* test_map;
b32b8144 FG	409	boost::unordered_multimap<test::object, test::object, test::hash,
b32b8144 FG	410	test::equal_to, test::allocator1<test::object> >* test_multimap;
7c673cae	411
b32b8144 FG	412	using test::default_generator;
	413	using test::generate_collisions;
	414	using test::limited_range;
7c673cae	415
b32b8144 FG	416	UNORDERED_TEST(constructor_tests1,
	417	((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))(
	418	(default_generator)(generate_collisions)(limited_range)))
7c673cae	419
b32b8144 FG	420	UNORDERED_TEST(constructor_tests2,
	421	((test_set)(test_multiset)(test_map)(test_multimap))(
	422	(default_generator)(generate_collisions)(limited_range)))
7c673cae	423
b32b8144 FG	424	UNORDERED_TEST(map_constructor_test,
	425	((test_map_std_alloc)(test_map)(test_multimap))(
	426	(default_generator)(generate_collisions)(limited_range)))
7c673cae FG	427
	428	#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
	429
b32b8144	430	UNORDERED_AUTO_TEST (test_default_initializer_list) {
7c673cae FG	431	std::initializer_list<int> init;
	432	boost::unordered_set<int> x1 = init;
	433	BOOST_TEST(x1.empty());
b32b8144	434	}
7c673cae FG	435
	436	#endif
	437
	438	#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
	439
b32b8144 FG	440	UNORDERED_AUTO_TEST (test_initializer_list) {
b32b8144 FG	441	boost::unordered_set<int> x1 = {2, 10, 45, -5};
7c673cae FG	442	BOOST_TEST(x1.find(10) != x1.end());
7c673cae FG	443	BOOST_TEST(x1.find(46) == x1.end());
b32b8144	444	}
7c673cae FG	445
7c673cae FG	446	#endif
7c673cae FG	447	}
7c673cae FG	448
b32b8144	449	RUN_TESTS_QUIET()