/Src/Dependencies/Boost/libs/unordered/test/unordered/constructor_tests.cpp

http://hadesmem.googlecode.com/ · C++ · 418 lines · 363 code · 52 blank · 3 comment · 3 complexity · efd73692dcefa9ab3c0df2af9a47eed5 MD5 · raw file

  1. // Copyright 2006-2010 Daniel James.
  2. // Distributed under the Boost Software License, Version 1.0. (See accompanying
  3. // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  4. #include "../helpers/prefix.hpp"
  5. #include <boost/unordered_set.hpp>
  6. #include <boost/unordered_map.hpp>
  7. #include "../helpers/test.hpp"
  8. #include "../objects/test.hpp"
  9. #include "../helpers/random_values.hpp"
  10. #include "../helpers/tracker.hpp"
  11. #include "../helpers/equivalent.hpp"
  12. #include "../helpers/input_iterator.hpp"
  13. #include "../helpers/invariants.hpp"
  14. #include <iostream>
  15. namespace constructor_tests {
  16. test::seed_t seed(356730);
  17. template <class T>
  18. void constructor_tests1(T*,
  19. test::random_generator generator = test::default_generator)
  20. {
  21. BOOST_DEDUCED_TYPENAME T::hasher hf;
  22. BOOST_DEDUCED_TYPENAME T::key_equal eq;
  23. BOOST_DEDUCED_TYPENAME T::allocator_type al;
  24. std::cerr<<"Construct 1\n";
  25. {
  26. T x(0, hf, eq);
  27. BOOST_TEST(x.empty());
  28. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  29. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  30. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  31. test::check_equivalent_keys(x);
  32. }
  33. std::cerr<<"Construct 2\n";
  34. {
  35. T x(100, hf);
  36. BOOST_TEST(x.empty());
  37. BOOST_TEST(x.bucket_count() >= 100);
  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. std::cerr<<"Construct 3\n";
  44. {
  45. T x(2000);
  46. BOOST_TEST(x.empty());
  47. BOOST_TEST(x.bucket_count() >= 2000);
  48. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  49. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  50. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  51. test::check_equivalent_keys(x);
  52. }
  53. std::cerr<<"Construct 4\n";
  54. {
  55. T x;
  56. BOOST_TEST(x.empty());
  57. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  58. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  59. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  60. test::check_equivalent_keys(x);
  61. }
  62. std::cerr<<"Construct 5\n";
  63. {
  64. test::random_values<T> v(1000, generator);
  65. T x(v.begin(), v.end(), 10000, hf, eq);
  66. BOOST_TEST(x.bucket_count() >= 10000);
  67. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  68. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  69. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  70. test::check_container(x, v);
  71. test::check_equivalent_keys(x);
  72. }
  73. std::cerr<<"Construct 6\n";
  74. {
  75. test::random_values<T> v(10, generator);
  76. T x(v.begin(), v.end(), 10000, hf);
  77. BOOST_TEST(x.bucket_count() >= 10000);
  78. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  79. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  80. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  81. test::check_container(x, v);
  82. test::check_equivalent_keys(x);
  83. }
  84. std::cerr<<"Construct 7\n";
  85. {
  86. test::random_values<T> v(100, generator);
  87. T x(v.begin(), v.end(), 100);
  88. BOOST_TEST(x.bucket_count() >= 100);
  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. std::cerr<<"Construct 8\n";
  96. {
  97. test::random_values<T> v(1, generator);
  98. T x(v.begin(), v.end());
  99. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  100. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  101. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  102. test::check_container(x, v);
  103. test::check_equivalent_keys(x);
  104. }
  105. std::cerr<<"Construct 9\n";
  106. {
  107. T x(0, hf, eq, al);
  108. BOOST_TEST(x.empty());
  109. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  110. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  111. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  112. test::check_equivalent_keys(x);
  113. }
  114. std::cerr<<"Construct 10\n";
  115. {
  116. test::random_values<T> v(1000, generator);
  117. T x(v.begin(), v.end(), 10000, hf, eq, al);
  118. BOOST_TEST(x.bucket_count() >= 10000);
  119. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  120. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  121. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  122. test::check_container(x, v);
  123. test::check_equivalent_keys(x);
  124. }
  125. std::cerr<<"Construct 11\n";
  126. {
  127. T x(al);
  128. BOOST_TEST(x.empty());
  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_equivalent_keys(x);
  133. }
  134. }
  135. template <class T>
  136. void constructor_tests2(T*,
  137. test::random_generator const& generator = test::default_generator)
  138. {
  139. BOOST_DEDUCED_TYPENAME T::hasher hf;
  140. BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
  141. BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
  142. BOOST_DEDUCED_TYPENAME T::key_equal eq;
  143. BOOST_DEDUCED_TYPENAME T::key_equal eq1(1);
  144. BOOST_DEDUCED_TYPENAME T::key_equal eq2(2);
  145. BOOST_DEDUCED_TYPENAME T::allocator_type al;
  146. BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
  147. BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
  148. std::cerr<<"Construct 1\n";
  149. {
  150. T x(10000, hf1, eq1);
  151. BOOST_TEST(x.bucket_count() >= 10000);
  152. BOOST_TEST(test::equivalent(x.hash_function(), hf1));
  153. BOOST_TEST(test::equivalent(x.key_eq(), eq1));
  154. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  155. test::check_equivalent_keys(x);
  156. }
  157. std::cerr<<"Construct 2\n";
  158. {
  159. T x(100, hf1);
  160. BOOST_TEST(x.empty());
  161. BOOST_TEST(x.bucket_count() >= 100);
  162. BOOST_TEST(test::equivalent(x.hash_function(), hf1));
  163. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  164. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  165. test::check_equivalent_keys(x);
  166. }
  167. std::cerr<<"Construct 3\n";
  168. {
  169. test::random_values<T> v(100, generator);
  170. T x(v.begin(), v.end(), 0, hf1, eq1);
  171. BOOST_TEST(test::equivalent(x.hash_function(), hf1));
  172. BOOST_TEST(test::equivalent(x.key_eq(), eq1));
  173. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  174. test::check_container(x, v);
  175. test::check_equivalent_keys(x);
  176. }
  177. std::cerr<<"Construct 4\n";
  178. {
  179. test::random_values<T> v(5, generator);
  180. T x(v.begin(), v.end(), 1000, hf1);
  181. BOOST_TEST(x.bucket_count() >= 1000);
  182. BOOST_TEST(test::equivalent(x.hash_function(), hf1));
  183. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  184. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  185. test::check_container(x, v);
  186. test::check_equivalent_keys(x);
  187. }
  188. std::cerr<<"Construct 5\n";
  189. {
  190. test::random_values<T> v(100, generator);
  191. T x(v.begin(), v.end(), 0, hf, eq, al1);
  192. T y(x.begin(), x.end(), 0, hf1, eq1, al2);
  193. test::check_container(x, v);
  194. test::check_container(y, x);
  195. test::check_equivalent_keys(x);
  196. test::check_equivalent_keys(y);
  197. }
  198. std::cerr<<"Construct 6\n";
  199. {
  200. test::random_values<T> v(100, generator);
  201. T x(v.begin(), v.end(), 0, hf1, eq1);
  202. T y(x.begin(), x.end(), 0, hf, eq);
  203. test::check_container(x, v);
  204. test::check_container(y, x);
  205. test::check_equivalent_keys(x);
  206. test::check_equivalent_keys(y);
  207. }
  208. std::cerr<<"Construct 7\n";
  209. {
  210. test::random_values<T> v(100, generator);
  211. T x(v.begin(), v.end(), 0, hf1, eq1);
  212. T y(x.begin(), x.end(), 0, hf2, eq2);
  213. test::check_container(x, v);
  214. test::check_container(y, x);
  215. test::check_equivalent_keys(x);
  216. test::check_equivalent_keys(y);
  217. }
  218. std::cerr<<"Construct 8 - from input iterator\n";
  219. {
  220. test::random_values<T> v(100, generator);
  221. BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
  222. v_begin = v.begin(), v_end = v.end();
  223. T x(test::input_iterator(v_begin),
  224. test::input_iterator(v_end), 0, hf1, eq1);
  225. BOOST_DEDUCED_TYPENAME T::const_iterator
  226. x_begin = x.begin(), x_end = x.end();
  227. T y(test::input_iterator(x_begin),
  228. test::input_iterator(x_end), 0, hf2, eq2);
  229. test::check_container(x, v);
  230. test::check_container(y, x);
  231. test::check_equivalent_keys(x);
  232. test::check_equivalent_keys(y);
  233. }
  234. std::cerr<<"Construct 8.5 - from copy iterator\n";
  235. {
  236. test::random_values<T> v(100, generator);
  237. T x(test::copy_iterator(v.begin()),
  238. test::copy_iterator(v.end()), 0, hf1, eq1);
  239. T y(test::copy_iterator(x.begin()),
  240. test::copy_iterator(x.end()), 0, hf2, eq2);
  241. test::check_container(x, v);
  242. test::check_container(y, x);
  243. test::check_equivalent_keys(x);
  244. test::check_equivalent_keys(y);
  245. }
  246. std::cerr<<"Construct 9\n";
  247. {
  248. test::random_values<T> v(100, generator);
  249. T x(50);
  250. BOOST_TEST(x.bucket_count() >= 50);
  251. x.max_load_factor(10);
  252. BOOST_TEST(x.bucket_count() >= 50);
  253. x.insert(v.begin(), v.end());
  254. BOOST_TEST(x.bucket_count() >= 50);
  255. test::check_container(x, v);
  256. test::check_equivalent_keys(x);
  257. }
  258. #if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
  259. std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
  260. std::cerr<<"Initializer list construct 1\n";
  261. {
  262. T x(list);
  263. BOOST_TEST(x.empty());
  264. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  265. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  266. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  267. }
  268. std::cerr<<"Initializer list construct 2\n";
  269. {
  270. T x(list, 1000);
  271. BOOST_TEST(x.empty());
  272. BOOST_TEST(x.bucket_count() >= 1000);
  273. BOOST_TEST(test::equivalent(x.hash_function(), hf));
  274. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  275. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  276. }
  277. std::cerr<<"Initializer list construct 3\n";
  278. {
  279. T x(list, 10, hf1);
  280. BOOST_TEST(x.empty());
  281. BOOST_TEST(x.bucket_count() >= 10);
  282. BOOST_TEST(test::equivalent(x.hash_function(), hf1));
  283. BOOST_TEST(test::equivalent(x.key_eq(), eq));
  284. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  285. }
  286. std::cerr<<"Initializer list construct 4\n";
  287. {
  288. T x(list, 10, hf1, eq1);
  289. BOOST_TEST(x.empty());
  290. BOOST_TEST(x.bucket_count() >= 10);
  291. BOOST_TEST(test::equivalent(x.hash_function(), hf1));
  292. BOOST_TEST(test::equivalent(x.key_eq(), eq1));
  293. BOOST_TEST(test::equivalent(x.get_allocator(), al));
  294. }
  295. std::cerr<<"Initializer list construct 5\n";
  296. {
  297. T x(list, 10, hf1, eq1, al1);
  298. BOOST_TEST(x.empty());
  299. BOOST_TEST(x.bucket_count() >= 10);
  300. BOOST_TEST(test::equivalent(x.hash_function(), hf1));
  301. BOOST_TEST(test::equivalent(x.key_eq(), eq1));
  302. BOOST_TEST(test::equivalent(x.get_allocator(), al1));
  303. }
  304. #endif
  305. }
  306. template <class T>
  307. void map_constructor_test(T* = 0,
  308. test::random_generator const& generator = test::default_generator)
  309. {
  310. std::cerr<<"map_constructor_test\n";
  311. typedef test::list<
  312. std::pair<
  313. BOOST_DEDUCED_TYPENAME T::key_type,
  314. BOOST_DEDUCED_TYPENAME T::mapped_type
  315. >
  316. > list;
  317. test::random_values<T> v(1000, generator);
  318. list l(v.begin(), v.end());
  319. T x(l.begin(), l.end());
  320. test::check_container(x, v);
  321. test::check_equivalent_keys(x);
  322. }
  323. boost::unordered_set<test::object,
  324. test::hash, test::equal_to,
  325. test::allocator<test::object> >* test_set;
  326. boost::unordered_multiset<test::object,
  327. test::hash, test::equal_to,
  328. test::allocator<test::object> >* test_multiset;
  329. boost::unordered_map<test::object, test::object,
  330. test::hash, test::equal_to,
  331. test::allocator<test::object> >* test_map;
  332. boost::unordered_multimap<test::object, test::object,
  333. test::hash, test::equal_to,
  334. test::allocator<test::object> >* test_multimap;
  335. using test::default_generator;
  336. using test::generate_collisions;
  337. UNORDERED_TEST(constructor_tests1,
  338. ((test_set)(test_multiset)(test_map)(test_multimap))
  339. ((default_generator)(generate_collisions))
  340. )
  341. UNORDERED_TEST(constructor_tests2,
  342. ((test_set)(test_multiset)(test_map)(test_multimap))
  343. ((default_generator)(generate_collisions))
  344. )
  345. UNORDERED_TEST(map_constructor_test,
  346. ((test_map)(test_multimap))
  347. )
  348. #if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST)
  349. UNORDERED_AUTO_TEST(test_default_initializer_list) {
  350. std::cerr<<"Initializer List Tests\n";
  351. std::initializer_list<int> init;
  352. boost::unordered_set<int> x1 = init;
  353. BOOST_TEST(x1.empty());
  354. }
  355. #endif
  356. #if !defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && \
  357. !defined(BOOST_NO_INITIALIZER_LISTS)
  358. UNORDERED_AUTO_TEST(test_initializer_list) {
  359. std::cerr<<"Initializer List Tests\n";
  360. boost::unordered_set<int> x1 = { 2, 10, 45, -5 };
  361. BOOST_TEST(x1.find(10) != x1.end());
  362. BOOST_TEST(x1.find(46) == x1.end());
  363. }
  364. #endif
  365. }
  366. RUN_TESTS()