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
main()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