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> constructor_tests1(T *,test::random_generator generator)26 void constructor_tests1(T*, test::random_generator generator) 27 { 28 typename T::hasher hf; 29 typename T::key_equal eq; 30 typename T::allocator_type al; 31 32 UNORDERED_SUB_TEST("Construct 1") 33 { 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); 42 } 43 44 UNORDERED_SUB_TEST("Construct 2") 45 { 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); 55 } 56 57 UNORDERED_SUB_TEST("Construct 3") 58 { 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); 68 } 69 70 UNORDERED_SUB_TEST("Construct 4") 71 { 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); 80 } 81 82 UNORDERED_SUB_TEST("Construct 5") 83 { 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); 94 } 95 96 UNORDERED_SUB_TEST("Construct 6") 97 { 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); 108 } 109 110 UNORDERED_SUB_TEST("Construct 7") 111 { 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); 122 } 123 124 UNORDERED_SUB_TEST("Construct 8") 125 { 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); 135 } 136 137 UNORDERED_SUB_TEST("Construct 9") 138 { 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); 147 } 148 149 UNORDERED_SUB_TEST("Construct 10") 150 { 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); 161 } 162 163 UNORDERED_SUB_TEST("Construct 11") 164 { 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); 173 } 174 } 175 176 template <class T> constructor_tests2(T *,test::random_generator const & generator)177 void constructor_tests2(T*, test::random_generator const& generator) 178 { 179 typename T::hasher hf; 180 typename T::hasher hf1(1); 181 typename T::hasher hf2(2); 182 typename T::key_equal eq; 183 typename T::key_equal eq1(1); 184 typename T::key_equal eq2(2); 185 typename T::allocator_type al; 186 typename T::allocator_type al1(1); 187 typename T::allocator_type al2(2); 188 189 UNORDERED_SUB_TEST("Construct 1") 190 { 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); 198 } 199 200 UNORDERED_SUB_TEST("Construct 2") 201 { 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); 210 } 211 212 UNORDERED_SUB_TEST("Construct 3") 213 { 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); 222 } 223 224 UNORDERED_SUB_TEST("Construct 4") 225 { 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); 235 } 236 237 UNORDERED_SUB_TEST("Construct 5") 238 { 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); 247 } 248 249 UNORDERED_SUB_TEST("Construct 6") 250 { 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); 259 } 260 261 UNORDERED_SUB_TEST("Construct 7") 262 { 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); 271 } 272 273 UNORDERED_SUB_TEST("Construct 8 - from input iterator") 274 { 275 test::check_instances check_; 276 test::random_values<T> v(100, generator); 277 typename test::random_values<T>::const_iterator 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 typename T::const_iterator x_begin = x.begin(), x_end = x.end(); 282 T y(test::input_iterator(x_begin), test::input_iterator(x_end), 0, hf2, 283 eq2); 284 test::check_container(x, v); 285 test::check_container(y, x); 286 test::check_equivalent_keys(x); 287 test::check_equivalent_keys(y); 288 } 289 290 UNORDERED_SUB_TEST("Construct 8.5 - from copy iterator") 291 { 292 test::check_instances check_; 293 test::random_values<T> v(100, generator); 294 T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0, hf1, 295 eq1); 296 T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0, hf2, 297 eq2); 298 test::check_container(x, v); 299 test::check_container(y, x); 300 test::check_equivalent_keys(x); 301 test::check_equivalent_keys(y); 302 } 303 304 UNORDERED_SUB_TEST("Construct 9") 305 { 306 test::check_instances check_; 307 308 test::random_values<T> v(100, generator); 309 T x(50); 310 BOOST_TEST(x.bucket_count() >= 50); 311 x.max_load_factor(10); 312 BOOST_TEST(x.bucket_count() >= 50); 313 x.insert(v.begin(), v.end()); 314 BOOST_TEST(x.bucket_count() >= 50); 315 test::check_container(x, v); 316 test::check_equivalent_keys(x); 317 } 318 319 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) 320 std::initializer_list<typename T::value_type> list; 321 322 UNORDERED_SUB_TEST("Initializer list construct 1") 323 { 324 test::check_instances check_; 325 326 T x(list); 327 BOOST_TEST(x.empty()); 328 BOOST_TEST(test::equivalent(x.hash_function(), hf)); 329 BOOST_TEST(test::equivalent(x.key_eq(), eq)); 330 BOOST_TEST(test::equivalent(x.get_allocator(), al)); 331 } 332 333 UNORDERED_SUB_TEST("Initializer list construct 2") 334 { 335 test::check_instances check_; 336 337 T x(list, 1000); 338 BOOST_TEST(x.empty()); 339 BOOST_TEST(x.bucket_count() >= 1000); 340 BOOST_TEST(test::equivalent(x.hash_function(), hf)); 341 BOOST_TEST(test::equivalent(x.key_eq(), eq)); 342 BOOST_TEST(test::equivalent(x.get_allocator(), al)); 343 } 344 345 UNORDERED_SUB_TEST("Initializer list construct 3") 346 { 347 test::check_instances check_; 348 349 T x(list, 10, hf1); 350 BOOST_TEST(x.empty()); 351 BOOST_TEST(x.bucket_count() >= 10); 352 BOOST_TEST(test::equivalent(x.hash_function(), hf1)); 353 BOOST_TEST(test::equivalent(x.key_eq(), eq)); 354 BOOST_TEST(test::equivalent(x.get_allocator(), al)); 355 } 356 357 UNORDERED_SUB_TEST("Initializer list construct 4") 358 { 359 test::check_instances check_; 360 361 T x(list, 10, hf1, eq1); 362 BOOST_TEST(x.empty()); 363 BOOST_TEST(x.bucket_count() >= 10); 364 BOOST_TEST(test::equivalent(x.hash_function(), hf1)); 365 BOOST_TEST(test::equivalent(x.key_eq(), eq1)); 366 BOOST_TEST(test::equivalent(x.get_allocator(), al)); 367 } 368 369 UNORDERED_SUB_TEST("Initializer list construct 5") 370 { 371 test::check_instances check_; 372 373 T x(list, 10, hf1, eq1, al1); 374 BOOST_TEST(x.empty()); 375 BOOST_TEST(x.bucket_count() >= 10); 376 BOOST_TEST(test::equivalent(x.hash_function(), hf1)); 377 BOOST_TEST(test::equivalent(x.key_eq(), eq1)); 378 BOOST_TEST(test::equivalent(x.get_allocator(), al1)); 379 } 380 #endif 381 } 382 383 template <class T> map_constructor_test(T *,test::random_generator const & generator)384 void map_constructor_test(T*, test::random_generator const& generator) 385 { 386 typedef test::list< 387 std::pair<typename T::key_type, typename T::mapped_type> > 388 list; 389 test::random_values<T> v(1000, generator); 390 list l(v.begin(), v.end()); 391 T x(l.begin(), l.end()); 392 393 test::check_container(x, v); 394 test::check_equivalent_keys(x); 395 } 396 397 boost::unordered_map<test::object, test::object, test::hash, test::equal_to, 398 std::allocator<test::object> >* test_map_std_alloc; 399 400 boost::unordered_set<test::object, test::hash, test::equal_to, 401 test::allocator1<test::object> >* test_set; 402 boost::unordered_multiset<test::object, test::hash, test::equal_to, 403 test::allocator2<test::object> >* test_multiset; 404 boost::unordered_map<test::object, test::object, test::hash, test::equal_to, 405 test::allocator2<test::object> >* test_map; 406 boost::unordered_multimap<test::object, test::object, test::hash, 407 test::equal_to, test::allocator1<test::object> >* test_multimap; 408 409 using test::default_generator; 410 using test::generate_collisions; 411 using test::limited_range; 412 413 UNORDERED_TEST(constructor_tests1, 414 ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))( 415 (default_generator)(generate_collisions)(limited_range))) 416 417 UNORDERED_TEST(constructor_tests2, 418 ((test_set)(test_multiset)(test_map)(test_multimap))( 419 (default_generator)(generate_collisions)(limited_range))) 420 421 UNORDERED_TEST(map_constructor_test, 422 ((test_map_std_alloc)(test_map)(test_multimap))( 423 (default_generator)(generate_collisions)(limited_range))) 424 425 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) 426 UNORDERED_AUTO_TEST(test_default_initializer_list)427 UNORDERED_AUTO_TEST (test_default_initializer_list) { 428 std::initializer_list<int> init; 429 boost::unordered_set<int> x1 = init; 430 BOOST_TEST(x1.empty()); 431 } 432 433 #endif 434 435 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) 436 UNORDERED_AUTO_TEST(test_initializer_list)437 UNORDERED_AUTO_TEST (test_initializer_list) { 438 boost::unordered_set<int> x1 = {2, 10, 45, -5}; 439 BOOST_TEST(x1.find(10) != x1.end()); 440 BOOST_TEST(x1.find(46) == x1.end()); 441 } 442 443 #endif 444 } 445 446 RUN_TESTS_QUIET() 447