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