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