libs/unordered/test/unordered/constructor_tests.cpp

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