1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03
10
11// <unordered_map>
12
13// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
14// class Alloc = allocator<pair<const Key, T>>>
15// class unordered_multimap
16
17// template <class P,
18// class = typename enable_if<is_convertible<P, value_type>::value>::type>
19// iterator insert(const_iterator p, P&& x);
20
21#include <unordered_map>
22#include <cassert>
23
24#include "test_macros.h"
25#include "MoveOnly.h"
26#include "min_allocator.h"
27
28int main(int, char**) {
29 {
30 typedef std::unordered_multimap<double, int> C;
31 typedef C::iterator R;
32 typedef std::pair<double, short> P;
33 C c;
34 C::const_iterator e = c.end();
35 R r = c.insert(hint: e, x: P(3.5, static_cast<short>(3)));
36 assert(c.size() == 1);
37 assert(r->first == 3.5);
38 assert(r->second == 3);
39
40 r = c.insert(hint: r, x: P(3.5, static_cast<short>(4)));
41 assert(c.size() == 2);
42 assert(r->first == 3.5);
43 assert(r->second == 4);
44
45 r = c.insert(hint: c.end(), x: P(4.5, static_cast<short>(4)));
46 assert(c.size() == 3);
47 assert(r->first == 4.5);
48 assert(r->second == 4);
49
50 r = c.insert(hint: c.end(), x: P(5.5, static_cast<short>(4)));
51 assert(c.size() == 4);
52 assert(r->first == 5.5);
53 assert(r->second == 4);
54 }
55 {
56 typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
57 typedef C::iterator R;
58 typedef std::pair<MoveOnly, MoveOnly> P;
59 C c;
60 C::const_iterator e = c.end();
61 R r = c.insert(e, P(3, 3));
62 assert(c.size() == 1);
63 assert(r->first == 3);
64 assert(r->second == 3);
65
66 r = c.insert(r, P(3, 4));
67 assert(c.size() == 2);
68 assert(r->first == 3);
69 assert(r->second == 4);
70
71 r = c.insert(c.end(), P(4, 4));
72 assert(c.size() == 3);
73 assert(r->first == 4);
74 assert(r->second == 4);
75
76 r = c.insert(c.end(), P(5, 4));
77 assert(c.size() == 4);
78 assert(r->first == 5);
79 assert(r->second == 4);
80 }
81 {
82 typedef std::unordered_multimap<double,
83 int,
84 std::hash<double>,
85 std::equal_to<double>,
86 min_allocator<std::pair<const double, int>>>
87 C;
88 typedef C::iterator R;
89 typedef std::pair<double, short> P;
90 C c;
91 C::const_iterator e = c.end();
92 R r = c.insert(e, P(3.5, static_cast<short>(3)));
93 assert(c.size() == 1);
94 assert(r->first == 3.5);
95 assert(r->second == 3);
96
97 r = c.insert(r, P(3.5, static_cast<short>(4)));
98 assert(c.size() == 2);
99 assert(r->first == 3.5);
100 assert(r->second == 4);
101
102 r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
103 assert(c.size() == 3);
104 assert(r->first == 4.5);
105 assert(r->second == 4);
106
107 r = c.insert(c.end(), P(5.5, static_cast<short>(4)));
108 assert(c.size() == 4);
109 assert(r->first == 5.5);
110 assert(r->second == 4);
111 }
112 {
113 typedef std::unordered_multimap<MoveOnly,
114 MoveOnly,
115 std::hash<MoveOnly>,
116 std::equal_to<MoveOnly>,
117 min_allocator<std::pair<const MoveOnly, MoveOnly>>>
118 C;
119 typedef C::iterator R;
120 typedef std::pair<MoveOnly, MoveOnly> P;
121 C c;
122 C::const_iterator e = c.end();
123 R r = c.insert(e, P(3, 3));
124 assert(c.size() == 1);
125 assert(r->first == 3);
126 assert(r->second == 3);
127
128 r = c.insert(r, P(3, 4));
129 assert(c.size() == 2);
130 assert(r->first == 3);
131 assert(r->second == 4);
132
133 r = c.insert(c.end(), P(4, 4));
134 assert(c.size() == 3);
135 assert(r->first == 4);
136 assert(r->second == 4);
137
138 r = c.insert(c.end(), P(5, 4));
139 assert(c.size() == 4);
140 assert(r->first == 5);
141 assert(r->second == 4);
142 }
143 {
144 typedef std::unordered_multimap<double, int> C;
145 typedef C::iterator R;
146 C c;
147 C::const_iterator e = c.end();
148 R r = c.insert(hint: e, x: {3.5, 3});
149 assert(c.size() == 1);
150 assert(r->first == 3.5);
151 assert(r->second == 3);
152
153 r = c.insert(hint: r, x: {3.5, 4});
154 assert(c.size() == 2);
155 assert(r->first == 3.5);
156 assert(r->second == 4);
157
158 r = c.insert(hint: c.end(), x: {4.5, 4});
159 assert(c.size() == 3);
160 assert(r->first == 4.5);
161 assert(r->second == 4);
162
163 r = c.insert(hint: c.end(), x: {5.5, 4});
164 assert(c.size() == 4);
165 assert(r->first == 5.5);
166 assert(r->second == 4);
167 }
168
169 return 0;
170}
171

source code of libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp