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_set
15
16 // unordered_set(const unordered_set& 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_set<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() == 4);
54 assert(c.count(1) == 1);
55 assert(c.count(2) == 1);
56 assert(c.count(3) == 1);
57 assert(c.count(4) == 1);
58 assert(c.hash_function() == test_hash<std::hash<int> >(8));
59 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
60 assert(c.get_allocator() == test_allocator<int>(10));
61 assert(!c.empty());
62 assert(std::distance(c.begin(), c.end()) == c.size());
63 assert(std::distance(c.cbegin(), c.cend()) == c.size());
64 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
65 assert(c.max_load_factor() == 1);
66 }
67 #ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
68 {
69 typedef std::unordered_set<int,
70 test_hash<std::hash<int> >,
71 test_compare<std::equal_to<int> >,
72 other_allocator<int>
73 > C;
74 typedef int P;
75 P a[] =
76 {
77 P(1),
78 P(2),
79 P(3),
80 P(4),
81 P(1),
82 P(2)
83 };
84 C c0(a, a + sizeof(a)/sizeof(a[0]),
85 7,
86 test_hash<std::hash<int> >(8),
87 test_compare<std::equal_to<int> >(9),
88 other_allocator<int>(10)
89 );
90 C c = c0;
91 assert(c.bucket_count() == 7);
92 assert(c.size() == 4);
93 assert(c.count(1) == 1);
94 assert(c.count(2) == 1);
95 assert(c.count(3) == 1);
96 assert(c.count(4) == 1);
97 assert(c.hash_function() == test_hash<std::hash<int> >(8));
98 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
99 assert(c.get_allocator() == other_allocator<int>(-2));
100 assert(!c.empty());
101 assert(std::distance(c.begin(), c.end()) == c.size());
102 assert(std::distance(c.cbegin(), c.cend()) == c.size());
103 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
104 assert(c.max_load_factor() == 1);
105 }
106 #endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
107 #if __cplusplus >= 201103L
108 {
109 typedef std::unordered_set<int,
110 test_hash<std::hash<int> >,
111 test_compare<std::equal_to<int> >,
112 min_allocator<int>
113 > C;
114 typedef int P;
115 P a[] =
116 {
117 P(1),
118 P(2),
119 P(3),
120 P(4),
121 P(1),
122 P(2)
123 };
124 C c0(a, a + sizeof(a)/sizeof(a[0]),
125 7,
126 test_hash<std::hash<int> >(8),
127 test_compare<std::equal_to<int> >(9),
128 min_allocator<int>()
129 );
130 C c = c0;
131 assert(c.bucket_count() == 7);
132 assert(c.size() == 4);
133 assert(c.count(1) == 1);
134 assert(c.count(2) == 1);
135 assert(c.count(3) == 1);
136 assert(c.count(4) == 1);
137 assert(c.hash_function() == test_hash<std::hash<int> >(8));
138 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
139 assert(c.get_allocator() == min_allocator<int>());
140 assert(!c.empty());
141 assert(std::distance(c.begin(), c.end()) == c.size());
142 assert(std::distance(c.cbegin(), c.cend()) == c.size());
143 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
144 assert(c.max_load_factor() == 1);
145 }
146 #endif
147 }
148