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 Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
13 // class Alloc = allocator<Value>>
14 // class unordered_multiset
15
16 // unordered_multiset(const unordered_multiset& u);
17
18 #include <unordered_set>
19 #include <cassert>
20 #include <cfloat>
21
22 #include "../../../test_compare.h"
23 #include "../../../test_hash.h"
24 #include "test_allocator.h"
25 #include "min_allocator.h"
26
main()27 int main()
28 {
29 {
30 typedef std::unordered_multiset<int,
31 test_hash<std::hash<int> >,
32 test_compare<std::equal_to<int> >,
33 test_allocator<int>
34 > C;
35 typedef int P;
36 P a[] =
37 {
38 P(1),
39 P(2),
40 P(3),
41 P(4),
42 P(1),
43 P(2)
44 };
45 C c0(a, a + sizeof(a)/sizeof(a[0]),
46 7,
47 test_hash<std::hash<int> >(8),
48 test_compare<std::equal_to<int> >(9),
49 test_allocator<int>(10)
50 );
51 C c = c0;
52 assert(c.bucket_count() == 7);
53 assert(c.size() == 6);
54 C::const_iterator i = c.cbegin();
55 assert(*i == 1);
56 ++i;
57 assert(*i == 1);
58 ++i;
59 assert(*i == 2);
60 ++i;
61 assert(*i == 2);
62 ++i;
63 assert(*i == 3);
64 ++i;
65 assert(*i == 4);
66 assert(c.hash_function() == test_hash<std::hash<int> >(8));
67 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
68 assert(c.get_allocator() == test_allocator<int>(10));
69 assert(!c.empty());
70 assert(std::distance(c.begin(), c.end()) == c.size());
71 assert(std::distance(c.cbegin(), c.cend()) == c.size());
72 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
73 assert(c.max_load_factor() == 1);
74 }
75 #ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
76 {
77 typedef std::unordered_multiset<int,
78 test_hash<std::hash<int> >,
79 test_compare<std::equal_to<int> >,
80 other_allocator<int>
81 > C;
82 typedef int P;
83 P a[] =
84 {
85 P(1),
86 P(2),
87 P(3),
88 P(4),
89 P(1),
90 P(2)
91 };
92 C c0(a, a + sizeof(a)/sizeof(a[0]),
93 7,
94 test_hash<std::hash<int> >(8),
95 test_compare<std::equal_to<int> >(9),
96 other_allocator<int>(10)
97 );
98 C c = c0;
99 assert(c.bucket_count() == 7);
100 assert(c.size() == 6);
101 C::const_iterator i = c.cbegin();
102 assert(*i == 1);
103 ++i;
104 assert(*i == 1);
105 ++i;
106 assert(*i == 2);
107 ++i;
108 assert(*i == 2);
109 ++i;
110 assert(*i == 3);
111 ++i;
112 assert(*i == 4);
113 assert(c.hash_function() == test_hash<std::hash<int> >(8));
114 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
115 assert(c.get_allocator() == other_allocator<int>(-2));
116 assert(!c.empty());
117 assert(std::distance(c.begin(), c.end()) == c.size());
118 assert(std::distance(c.cbegin(), c.cend()) == c.size());
119 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
120 assert(c.max_load_factor() == 1);
121 }
122 #endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
123 #if __cplusplus >= 201103L
124 {
125 typedef std::unordered_multiset<int,
126 test_hash<std::hash<int> >,
127 test_compare<std::equal_to<int> >,
128 min_allocator<int>
129 > C;
130 typedef int P;
131 P a[] =
132 {
133 P(1),
134 P(2),
135 P(3),
136 P(4),
137 P(1),
138 P(2)
139 };
140 C c0(a, a + sizeof(a)/sizeof(a[0]),
141 7,
142 test_hash<std::hash<int> >(8),
143 test_compare<std::equal_to<int> >(9),
144 min_allocator<int>()
145 );
146 C c = c0;
147 assert(c.bucket_count() == 7);
148 assert(c.size() == 6);
149 C::const_iterator i = c.cbegin();
150 assert(*i == 1);
151 ++i;
152 assert(*i == 1);
153 ++i;
154 assert(*i == 2);
155 ++i;
156 assert(*i == 2);
157 ++i;
158 assert(*i == 3);
159 ++i;
160 assert(*i == 4);
161 assert(c.hash_function() == test_hash<std::hash<int> >(8));
162 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
163 assert(c.get_allocator() == min_allocator<int>());
164 assert(!c.empty());
165 assert(std::distance(c.begin(), c.end()) == c.size());
166 assert(std::distance(c.cbegin(), c.cend()) == c.size());
167 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
168 assert(c.max_load_factor() == 1);
169 }
170 #endif
171 }
172