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_map>
11 
12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
13 //           class Alloc = allocator<pair<const Key, T>>>
14 // class unordered_map
15 
16 // template <class P,
17 //           class = typename enable_if<is_convertible<P, value_type>::value>::type>
18 //     pair<iterator, bool> insert(P&& x);
19 
20 #include <unordered_map>
21 #include <cassert>
22 
23 #include "../../../MoveOnly.h"
24 #include "../../../min_allocator.h"
25 
26 int main()
27 {
28     {
29         typedef std::unordered_map<double, int> C;
30         typedef std::pair<C::iterator, bool> R;
31         typedef std::pair<double, short> P;
32         C c;
33         R r = c.insert(P(3.5, 3));
34         assert(r.second);
35         assert(c.size() == 1);
36         assert(r.first->first == 3.5);
37         assert(r.first->second == 3);
38 
39         r = c.insert(P(3.5, 4));
40         assert(!r.second);
41         assert(c.size() == 1);
42         assert(r.first->first == 3.5);
43         assert(r.first->second == 3);
44 
45         r = c.insert(P(4.5, 4));
46         assert(r.second);
47         assert(c.size() == 2);
48         assert(r.first->first == 4.5);
49         assert(r.first->second == 4);
50 
51         r = c.insert(P(5.5, 4));
52         assert(r.second);
53         assert(c.size() == 3);
54         assert(r.first->first == 5.5);
55         assert(r.first->second == 4);
56     }
57 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
58     {
59         typedef std::unordered_map<MoveOnly, MoveOnly> C;
60         typedef std::pair<C::iterator, bool> R;
61         typedef std::pair<MoveOnly, MoveOnly> P;
62         C c;
63         R r = c.insert(P(3, 3));
64         assert(r.second);
65         assert(c.size() == 1);
66         assert(r.first->first == 3);
67         assert(r.first->second == 3);
68 
69         r = c.insert(P(3, 4));
70         assert(!r.second);
71         assert(c.size() == 1);
72         assert(r.first->first == 3);
73         assert(r.first->second == 3);
74 
75         r = c.insert(P(4, 4));
76         assert(r.second);
77         assert(c.size() == 2);
78         assert(r.first->first == 4);
79         assert(r.first->second == 4);
80 
81         r = c.insert(P(5, 4));
82         assert(r.second);
83         assert(c.size() == 3);
84         assert(r.first->first == 5);
85         assert(r.first->second == 4);
86     }
87 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
88 #if __cplusplus >= 201103L
89     {
90         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
91                             min_allocator<std::pair<const double, int>>> C;
92         typedef std::pair<C::iterator, bool> R;
93         typedef std::pair<double, short> P;
94         C c;
95         R r = c.insert(P(3.5, 3));
96         assert(r.second);
97         assert(c.size() == 1);
98         assert(r.first->first == 3.5);
99         assert(r.first->second == 3);
100 
101         r = c.insert(P(3.5, 4));
102         assert(!r.second);
103         assert(c.size() == 1);
104         assert(r.first->first == 3.5);
105         assert(r.first->second == 3);
106 
107         r = c.insert(P(4.5, 4));
108         assert(r.second);
109         assert(c.size() == 2);
110         assert(r.first->first == 4.5);
111         assert(r.first->second == 4);
112 
113         r = c.insert(P(5.5, 4));
114         assert(r.second);
115         assert(c.size() == 3);
116         assert(r.first->first == 5.5);
117         assert(r.first->second == 4);
118     }
119 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
120     {
121         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
122                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
123         typedef std::pair<C::iterator, bool> R;
124         typedef std::pair<MoveOnly, MoveOnly> P;
125         C c;
126         R r = c.insert(P(3, 3));
127         assert(r.second);
128         assert(c.size() == 1);
129         assert(r.first->first == 3);
130         assert(r.first->second == 3);
131 
132         r = c.insert(P(3, 4));
133         assert(!r.second);
134         assert(c.size() == 1);
135         assert(r.first->first == 3);
136         assert(r.first->second == 3);
137 
138         r = c.insert(P(4, 4));
139         assert(r.second);
140         assert(c.size() == 2);
141         assert(r.first->first == 4);
142         assert(r.first->second == 4);
143 
144         r = c.insert(P(5, 4));
145         assert(r.second);
146         assert(c.size() == 3);
147         assert(r.first->first == 5);
148         assert(r.first->second == 4);
149     }
150 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
151 #endif
152 }
153