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

http://hadesmem.googlecode.com/ · C++ · 171 lines · 141 code · 25 blank · 5 comment · 18 complexity · 032bb974fea3013536736a546d27e06e MD5 · raw file

  1. // Copyright 2008-2009 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 <boost/preprocessor/seq.hpp>
  8. #include <list>
  9. #include "../helpers/test.hpp"
  10. namespace equality_tests
  11. {
  12. struct mod_compare
  13. {
  14. bool alt_hash_;
  15. explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
  16. bool operator()(int x, int y) const
  17. {
  18. return x % 1000 == y % 1000;
  19. }
  20. int operator()(int x) const
  21. {
  22. return alt_hash_ ? x % 250 : (x + 5) % 250;
  23. }
  24. };
  25. #define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2) \
  26. { \
  27. boost::unordered_set<int, mod_compare, mod_compare> set1, set2; \
  28. BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
  29. BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
  30. BOOST_TEST(set1 op set2); \
  31. }
  32. #define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2) \
  33. { \
  34. boost::unordered_multiset<int, mod_compare, mod_compare> \
  35. set1, set2; \
  36. BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
  37. BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
  38. BOOST_TEST(set1 op set2); \
  39. }
  40. #define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2) \
  41. { \
  42. boost::unordered_map<int, int, mod_compare, mod_compare> \
  43. map1, map2; \
  44. BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
  45. BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
  46. BOOST_TEST(map1 op map2); \
  47. }
  48. #define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2) \
  49. { \
  50. boost::unordered_multimap<int, int, mod_compare, mod_compare> \
  51. map1, map2; \
  52. BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
  53. BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
  54. BOOST_TEST(map1 op map2); \
  55. }
  56. #define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
  57. #define UNORDERED_MAP_INSERT(r, map, item) \
  58. map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
  59. UNORDERED_AUTO_TEST(equality_size_tests)
  60. {
  61. boost::unordered_set<int> x1, x2;
  62. BOOST_TEST(x1 == x2);
  63. BOOST_TEST(!(x1 != x2));
  64. x1.insert(1);
  65. BOOST_TEST(x1 != x2);
  66. BOOST_TEST(!(x1 == x2));
  67. BOOST_TEST(x2 != x1);
  68. BOOST_TEST(!(x2 == x1));
  69. x2.insert(1);
  70. BOOST_TEST(x1 == x2);
  71. BOOST_TEST(!(x1 != x2));
  72. x2.insert(2);
  73. BOOST_TEST(x1 != x2);
  74. BOOST_TEST(!(x1 == x2));
  75. BOOST_TEST(x2 != x1);
  76. BOOST_TEST(!(x2 == x1));
  77. }
  78. UNORDERED_AUTO_TEST(equality_key_value_tests)
  79. {
  80. UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2))
  81. UNORDERED_EQUALITY_SET_TEST((2), ==, (2))
  82. UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)))
  83. }
  84. UNORDERED_AUTO_TEST(equality_collision_test)
  85. {
  86. UNORDERED_EQUALITY_MULTISET_TEST(
  87. (1), !=, (501))
  88. UNORDERED_EQUALITY_MULTISET_TEST(
  89. (1)(251), !=, (1)(501))
  90. UNORDERED_EQUALITY_MULTIMAP_TEST(
  91. ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)))
  92. UNORDERED_EQUALITY_MULTISET_TEST(
  93. (1)(501), ==, (1)(501))
  94. UNORDERED_EQUALITY_SET_TEST(
  95. (1)(501), ==, (501)(1))
  96. }
  97. UNORDERED_AUTO_TEST(equality_group_size_test)
  98. {
  99. UNORDERED_EQUALITY_MULTISET_TEST(
  100. (10)(20)(20), !=, (10)(10)(20))
  101. UNORDERED_EQUALITY_MULTIMAP_TEST(
  102. ((10)(1))((20)(1))((20)(1)), !=,
  103. ((10)(1))((20)(1))((10)(1)))
  104. UNORDERED_EQUALITY_MULTIMAP_TEST(
  105. ((20)(1))((10)(1))((10)(1)), ==,
  106. ((10)(1))((20)(1))((10)(1)))
  107. }
  108. UNORDERED_AUTO_TEST(equality_map_value_test)
  109. {
  110. UNORDERED_EQUALITY_MAP_TEST(
  111. ((1)(1)), !=, ((1)(2)))
  112. UNORDERED_EQUALITY_MAP_TEST(
  113. ((1)(1)), ==, ((1)(1)))
  114. UNORDERED_EQUALITY_MULTIMAP_TEST(
  115. ((1)(1)), !=, ((1)(2)))
  116. UNORDERED_EQUALITY_MULTIMAP_TEST(
  117. ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
  118. UNORDERED_EQUALITY_MULTIMAP_TEST(
  119. ((1)(2))((1)(1)), !=, ((1)(1))((1)(2)))
  120. }
  121. UNORDERED_AUTO_TEST(equality_predicate_test)
  122. {
  123. UNORDERED_EQUALITY_SET_TEST(
  124. (1), ==, (1001))
  125. UNORDERED_EQUALITY_MAP_TEST(
  126. ((1)(2))((1001)(1)), ==, ((1001)(2))((1)(1)))
  127. }
  128. // Test that equality still works when the two containers have
  129. // different hash functions but the same equality predicate.
  130. UNORDERED_AUTO_TEST(equality_different_hash_test)
  131. {
  132. typedef boost::unordered_set<int, mod_compare, mod_compare> set;
  133. set set1(0, mod_compare(false), mod_compare(false));
  134. set set2(0, mod_compare(true), mod_compare(true));
  135. BOOST_TEST(set1 == set2);
  136. set1.insert(1); set2.insert(2);
  137. BOOST_TEST(set1 != set2);
  138. set1.insert(2); set2.insert(1);
  139. BOOST_TEST(set1 == set2);
  140. set1.insert(10); set2.insert(20);
  141. BOOST_TEST(set1 != set2);
  142. set1.insert(20); set2.insert(10);
  143. BOOST_TEST(set1 == set2);
  144. }
  145. }
  146. RUN_TESTS()