1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <unordered_set>
11
12 // template <class Key, class Hash, class Pred, class Alloc>
13 // bool
14 // operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& x,
15 // const unordered_multiset<Key, Hash, Pred, Alloc>& y);
16 //
17 // template <class Key, class Hash, class Pred, class Alloc>
18 // bool
19 // operator!=(const unordered_multiset<Key, Hash, Pred, Alloc>& x,
20 // const unordered_multiset<Key, Hash, Pred, Alloc>& y);
21
22 #include <unordered_set>
23 #include <cassert>
24
25 #include "min_allocator.h"
26
main()27 int main()
28 {
29 {
30 typedef std::unordered_multiset<int> C;
31 typedef int P;
32 P a[] =
33 {
34 P(10),
35 P(20),
36 P(20),
37 P(30),
38 P(40),
39 P(50),
40 P(50),
41 P(50),
42 P(60),
43 P(70),
44 P(80)
45 };
46 const C c1(std::begin(a), std::end(a));
47 const C c2;
48 assert(!(c1 == c2));
49 assert( (c1 != c2));
50 }
51 {
52 typedef std::unordered_multiset<int> C;
53 typedef int P;
54 P a[] =
55 {
56 P(10),
57 P(20),
58 P(20),
59 P(30),
60 P(40),
61 P(50),
62 P(50),
63 P(50),
64 P(60),
65 P(70),
66 P(80)
67 };
68 const C c1(std::begin(a), std::end(a));
69 const C c2 = c1;
70 assert( (c1 == c2));
71 assert(!(c1 != c2));
72 }
73 {
74 typedef std::unordered_multiset<int> C;
75 typedef int P;
76 P a[] =
77 {
78 P(10),
79 P(20),
80 P(20),
81 P(30),
82 P(40),
83 P(50),
84 P(50),
85 P(50),
86 P(60),
87 P(70),
88 P(80)
89 };
90 C c1(std::begin(a), std::end(a));
91 C c2 = c1;
92 c2.rehash(30);
93 assert( (c1 == c2));
94 assert(!(c1 != c2));
95 c2.insert(P(90));
96 assert(!(c1 == c2));
97 assert( (c1 != c2));
98 c1.insert(P(90));
99 assert( (c1 == c2));
100 assert(!(c1 != c2));
101 }
102 #if __cplusplus >= 201103L
103 {
104 typedef std::unordered_multiset<int, std::hash<int>,
105 std::equal_to<int>, min_allocator<int>> C;
106 typedef int P;
107 P a[] =
108 {
109 P(10),
110 P(20),
111 P(20),
112 P(30),
113 P(40),
114 P(50),
115 P(50),
116 P(50),
117 P(60),
118 P(70),
119 P(80)
120 };
121 const C c1(std::begin(a), std::end(a));
122 const C c2;
123 assert(!(c1 == c2));
124 assert( (c1 != c2));
125 }
126 {
127 typedef std::unordered_multiset<int, std::hash<int>,
128 std::equal_to<int>, min_allocator<int>> C;
129 typedef int P;
130 P a[] =
131 {
132 P(10),
133 P(20),
134 P(20),
135 P(30),
136 P(40),
137 P(50),
138 P(50),
139 P(50),
140 P(60),
141 P(70),
142 P(80)
143 };
144 const C c1(std::begin(a), std::end(a));
145 const C c2 = c1;
146 assert( (c1 == c2));
147 assert(!(c1 != c2));
148 }
149 {
150 typedef std::unordered_multiset<int, std::hash<int>,
151 std::equal_to<int>, min_allocator<int>> C;
152 typedef int P;
153 P a[] =
154 {
155 P(10),
156 P(20),
157 P(20),
158 P(30),
159 P(40),
160 P(50),
161 P(50),
162 P(50),
163 P(60),
164 P(70),
165 P(80)
166 };
167 C c1(std::begin(a), std::end(a));
168 C c2 = c1;
169 c2.rehash(30);
170 assert( (c1 == c2));
171 assert(!(c1 != c2));
172 c2.insert(P(90));
173 assert(!(c1 == c2));
174 assert( (c1 != c2));
175 c1.insert(P(90));
176 assert( (c1 == c2));
177 assert(!(c1 != c2));
178 }
179 #endif
180 }
181