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 // pair<iterator, bool> insert(value_type&& x);
17
18 #include <unordered_set>
19 #include <cassert>
20
21 #include "test_macros.h"
22 #include "MoveOnly.h"
23 #include "min_allocator.h"
24
main()25 int main()
26 {
27 {
28 typedef std::unordered_set<double> C;
29 typedef std::pair<C::iterator, bool> R;
30 typedef double P;
31 C c;
32 R r = c.insert(P(3.5));
33 assert(c.size() == 1);
34 assert(*r.first == 3.5);
35 assert(r.second);
36
37 r = c.insert(P(3.5));
38 assert(c.size() == 1);
39 assert(*r.first == 3.5);
40 assert(!r.second);
41
42 r = c.insert(P(4.5));
43 assert(c.size() == 2);
44 assert(*r.first == 4.5);
45 assert(r.second);
46
47 r = c.insert(P(5.5));
48 assert(c.size() == 3);
49 assert(*r.first == 5.5);
50 assert(r.second);
51 }
52 #if TEST_STD_VER >= 11
53 {
54 typedef std::unordered_set<MoveOnly> C;
55 typedef std::pair<C::iterator, bool> R;
56 typedef MoveOnly P;
57 C c;
58 R r = c.insert(P(3));
59 assert(c.size() == 1);
60 assert(*r.first == 3);
61 assert(r.second);
62
63 r = c.insert(P(3));
64 assert(c.size() == 1);
65 assert(*r.first == 3);
66 assert(!r.second);
67
68 r = c.insert(P(4));
69 assert(c.size() == 2);
70 assert(*r.first == 4);
71 assert(r.second);
72
73 r = c.insert(P(5));
74 assert(c.size() == 3);
75 assert(*r.first == 5);
76 assert(r.second);
77 }
78 {
79 typedef std::unordered_set<double, std::hash<double>,
80 std::equal_to<double>, min_allocator<double>> C;
81 typedef std::pair<C::iterator, bool> R;
82 typedef double P;
83 C c;
84 R r = c.insert(P(3.5));
85 assert(c.size() == 1);
86 assert(*r.first == 3.5);
87 assert(r.second);
88
89 r = c.insert(P(3.5));
90 assert(c.size() == 1);
91 assert(*r.first == 3.5);
92 assert(!r.second);
93
94 r = c.insert(P(4.5));
95 assert(c.size() == 2);
96 assert(*r.first == 4.5);
97 assert(r.second);
98
99 r = c.insert(P(5.5));
100 assert(c.size() == 3);
101 assert(*r.first == 5.5);
102 assert(r.second);
103 }
104 {
105 typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
106 std::equal_to<MoveOnly>, min_allocator<MoveOnly>> C;
107 typedef std::pair<C::iterator, bool> R;
108 typedef MoveOnly P;
109 C c;
110 R r = c.insert(P(3));
111 assert(c.size() == 1);
112 assert(*r.first == 3);
113 assert(r.second);
114
115 r = c.insert(P(3));
116 assert(c.size() == 1);
117 assert(*r.first == 3);
118 assert(!r.second);
119
120 r = c.insert(P(4));
121 assert(c.size() == 2);
122 assert(*r.first == 4);
123 assert(r.second);
124
125 r = c.insert(P(5));
126 assert(c.size() == 3);
127 assert(*r.first == 5);
128 assert(r.second);
129 }
130 #endif // TEST_STD_VER >= 11
131 }
132