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