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// <map>
11
12// class multimap
13
14// template <class... Args>
15//   iterator emplace_hint(const_iterator position, Args&&... args);
16
17#include <map>
18#include <cassert>
19
20#include "../../../Emplaceable.h"
21#include "DefaultOnly.h"
22#include "min_allocator.h"
23
24int main()
25{
26#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
27    {
28        typedef std::multimap<int, DefaultOnly> M;
29        typedef M::iterator R;
30        M m;
31        assert(DefaultOnly::count == 0);
32        R r = m.emplace_hint(m.cend());
33        assert(r == m.begin());
34        assert(m.size() == 1);
35        assert(m.begin()->first == 0);
36        assert(m.begin()->second == DefaultOnly());
37        assert(DefaultOnly::count == 1);
38        r = m.emplace_hint(m.cend(), std::piecewise_construct,
39                                       std::forward_as_tuple(1),
40                                       std::forward_as_tuple());
41        assert(r == next(m.begin()));
42        assert(m.size() == 2);
43        assert(next(m.begin())->first == 1);
44        assert(next(m.begin())->second == DefaultOnly());
45        assert(DefaultOnly::count == 2);
46        r = m.emplace_hint(m.cend(), std::piecewise_construct,
47                                       std::forward_as_tuple(1),
48                                       std::forward_as_tuple());
49        assert(r == next(m.begin(), 2));
50        assert(m.size() == 3);
51        assert(next(m.begin(), 2)->first == 1);
52        assert(next(m.begin(), 2)->second == DefaultOnly());
53        assert(DefaultOnly::count == 3);
54    }
55    assert(DefaultOnly::count == 0);
56    {
57        typedef std::multimap<int, Emplaceable> M;
58        typedef M::iterator R;
59        M m;
60        R r = m.emplace_hint(m.cend(), std::piecewise_construct,
61                                       std::forward_as_tuple(2),
62                                       std::forward_as_tuple());
63        assert(r == m.begin());
64        assert(m.size() == 1);
65        assert(m.begin()->first == 2);
66        assert(m.begin()->second == Emplaceable());
67        r = m.emplace_hint(m.cbegin(), std::piecewise_construct,
68                                       std::forward_as_tuple(1),
69                                       std::forward_as_tuple(2, 3.5));
70        assert(r == m.begin());
71        assert(m.size() == 2);
72        assert(m.begin()->first == 1);
73        assert(m.begin()->second == Emplaceable(2, 3.5));
74        r = m.emplace_hint(m.cbegin(), std::piecewise_construct,
75                                       std::forward_as_tuple(1),
76                                       std::forward_as_tuple(3, 3.5));
77        assert(r == m.begin());
78        assert(m.size() == 3);
79        assert(r->first == 1);
80        assert(r->second == Emplaceable(3, 3.5));
81    }
82    {
83        typedef std::multimap<int, double> M;
84        typedef M::iterator R;
85        M m;
86        R r = m.emplace_hint(m.cend(), M::value_type(2, 3.5));
87        assert(r == m.begin());
88        assert(m.size() == 1);
89        assert(m.begin()->first == 2);
90        assert(m.begin()->second == 3.5);
91    }
92#if __cplusplus >= 201103L
93    {
94        typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
95        typedef M::iterator R;
96        M m;
97        assert(DefaultOnly::count == 0);
98        R r = m.emplace_hint(m.cend());
99        assert(r == m.begin());
100        assert(m.size() == 1);
101        assert(m.begin()->first == 0);
102        assert(m.begin()->second == DefaultOnly());
103        assert(DefaultOnly::count == 1);
104        r = m.emplace_hint(m.cend(), std::piecewise_construct,
105                                       std::forward_as_tuple(1),
106                                       std::forward_as_tuple());
107        assert(r == next(m.begin()));
108        assert(m.size() == 2);
109        assert(next(m.begin())->first == 1);
110        assert(next(m.begin())->second == DefaultOnly());
111        assert(DefaultOnly::count == 2);
112        r = m.emplace_hint(m.cend(), std::piecewise_construct,
113                                       std::forward_as_tuple(1),
114                                       std::forward_as_tuple());
115        assert(r == next(m.begin(), 2));
116        assert(m.size() == 3);
117        assert(next(m.begin(), 2)->first == 1);
118        assert(next(m.begin(), 2)->second == DefaultOnly());
119        assert(DefaultOnly::count == 3);
120    }
121    assert(DefaultOnly::count == 0);
122    {
123        typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M;
124        typedef M::iterator R;
125        M m;
126        R r = m.emplace_hint(m.cend(), std::piecewise_construct,
127                                       std::forward_as_tuple(2),
128                                       std::forward_as_tuple());
129        assert(r == m.begin());
130        assert(m.size() == 1);
131        assert(m.begin()->first == 2);
132        assert(m.begin()->second == Emplaceable());
133        r = m.emplace_hint(m.cbegin(), std::piecewise_construct,
134                                       std::forward_as_tuple(1),
135                                       std::forward_as_tuple(2, 3.5));
136        assert(r == m.begin());
137        assert(m.size() == 2);
138        assert(m.begin()->first == 1);
139        assert(m.begin()->second == Emplaceable(2, 3.5));
140        r = m.emplace_hint(m.cbegin(), std::piecewise_construct,
141                                       std::forward_as_tuple(1),
142                                       std::forward_as_tuple(3, 3.5));
143        assert(r == m.begin());
144        assert(m.size() == 3);
145        assert(r->first == 1);
146        assert(r->second == Emplaceable(3, 3.5));
147    }
148    {
149        typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
150        typedef M::iterator R;
151        M m;
152        R r = m.emplace_hint(m.cend(), M::value_type(2, 3.5));
153        assert(r == m.begin());
154        assert(m.size() == 1);
155        assert(m.begin()->first == 2);
156        assert(m.begin()->second == 3.5);
157    }
158#endif
159#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
160}
161