1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // <unordered_map>
10
11 // template <class Key, class T, class Hash, class Pred, class Alloc>
12 // bool
13 // operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
14 // const unordered_map<Key, T, Hash, Pred, Alloc>& y);
15 //
16 // template <class Key, class T, class Hash, class Pred, class Alloc>
17 // bool
18 // operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
19 // const unordered_map<Key, T, Hash, Pred, Alloc>& y);
20
21 #include <unordered_map>
22 #include <string>
23 #include <cassert>
24 #include <iterator>
25
26 #include "test_macros.h"
27 #include "min_allocator.h"
28
29 #include "test_comparisons.h"
30
main(int,char **)31 int main(int, char**)
32 {
33 {
34 typedef std::unordered_map<int, std::string> C;
35 typedef std::pair<int, std::string> P;
36 P a[] =
37 {
38 P(10, "ten"),
39 P(20, "twenty"),
40 P(30, "thirty"),
41 P(40, "forty"),
42 P(50, "fifty"),
43 P(60, "sixty"),
44 P(70, "seventy"),
45 P(80, "eighty"),
46 };
47 const C c1(std::begin(a), std::end(a));
48 const C c2;
49 assert(testEquality(c1, c2, false));
50 }
51 {
52 typedef std::unordered_map<int, std::string> C;
53 typedef std::pair<int, std::string> P;
54 P a[] =
55 {
56 P(10, "ten"),
57 P(20, "twenty"),
58 P(30, "thirty"),
59 P(40, "forty"),
60 P(50, "fifty"),
61 P(60, "sixty"),
62 P(70, "seventy"),
63 P(80, "eighty"),
64 };
65 const C c1(std::begin(a), std::end(a));
66 const C c2 = c1;
67 assert(testEquality(c1, c2, true));
68 }
69 {
70 typedef std::unordered_map<int, std::string> C;
71 typedef std::pair<int, std::string> P;
72 P a[] =
73 {
74 P(10, "ten"),
75 P(20, "twenty"),
76 P(30, "thirty"),
77 P(40, "forty"),
78 P(50, "fifty"),
79 P(60, "sixty"),
80 P(70, "seventy"),
81 P(80, "eighty"),
82 };
83 C c1(std::begin(a), std::end(a));
84 C c2 = c1;
85 c2.rehash(30);
86 assert(testEquality(c1, c2, true));
87 c2.insert(P(90, "ninety"));
88 assert(testEquality(c1, c2, false));
89 c1.insert(P(90, "ninety"));
90 assert(testEquality(c1, c2, true));
91 }
92 {
93 typedef std::unordered_map<int, std::string> C;
94 typedef std::pair<int, std::string> P;
95 P a[] =
96 {
97 P(10, "ten"),
98 P(20, "twenty"),
99 P(30, "thirty"),
100 P(40, "forty"),
101 P(50, "fifty"),
102 P(60, "sixty"),
103 P(70, "seventy"),
104 P(80, "eighty"),
105 };
106 C c1(std::begin(a), std::end(a));
107 C c2 = c1;
108 assert(testEquality(c1, c2, true));
109 c1.insert(P(90, "ninety"));
110 c2.insert(P(100, "onehundred"));
111 assert(testEquality(c1, c2, false));
112 }
113 #if TEST_STD_VER >= 11
114 {
115 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
116 min_allocator<std::pair<const int, std::string>>> C;
117 typedef std::pair<int, std::string> P;
118 P a[] =
119 {
120 P(10, "ten"),
121 P(20, "twenty"),
122 P(30, "thirty"),
123 P(40, "forty"),
124 P(50, "fifty"),
125 P(60, "sixty"),
126 P(70, "seventy"),
127 P(80, "eighty"),
128 };
129 const C c1(std::begin(a), std::end(a));
130 const C c2;
131 assert(testEquality(c1, c2, false));
132 }
133 {
134 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
135 min_allocator<std::pair<const int, std::string>>> C;
136 typedef std::pair<int, std::string> P;
137 P a[] =
138 {
139 P(10, "ten"),
140 P(20, "twenty"),
141 P(30, "thirty"),
142 P(40, "forty"),
143 P(50, "fifty"),
144 P(60, "sixty"),
145 P(70, "seventy"),
146 P(80, "eighty"),
147 };
148 const C c1(std::begin(a), std::end(a));
149 const C c2 = c1;
150 assert(testEquality(c1, c2, true));
151 }
152 {
153 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
154 min_allocator<std::pair<const int, std::string>>> C;
155 typedef std::pair<int, std::string> P;
156 P a[] =
157 {
158 P(10, "ten"),
159 P(20, "twenty"),
160 P(30, "thirty"),
161 P(40, "forty"),
162 P(50, "fifty"),
163 P(60, "sixty"),
164 P(70, "seventy"),
165 P(80, "eighty"),
166 };
167 C c1(std::begin(a), std::end(a));
168 C c2 = c1;
169 c2.rehash(30);
170 assert(testEquality(c1, c2, true));
171 c2.insert(P(90, "ninety"));
172 assert(testEquality(c1, c2, false));
173 c1.insert(P(90, "ninety"));
174 assert(testEquality(c1, c2, true));
175 }
176 {
177 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
178 min_allocator<std::pair<const int, std::string>>> C;
179 typedef std::pair<int, std::string> P;
180 P a[] =
181 {
182 P(10, "ten"),
183 P(20, "twenty"),
184 P(30, "thirty"),
185 P(40, "forty"),
186 P(50, "fifty"),
187 P(60, "sixty"),
188 P(70, "seventy"),
189 P(80, "eighty"),
190 };
191 C c1(std::begin(a), std::end(a));
192 C c2 = c1;
193 assert(testEquality(c1, c2, true));
194 c1.insert(P(90, "ninety"));
195 c2.insert(P(100, "onehundred"));
196 assert(testEquality(c1, c2, false));
197 }
198 #endif
199
200 return 0;
201 }
202