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