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// iterator erase(const_iterator p)
17
18#include <unordered_map>
19#include <string>
20#include <cassert>
21#include <cstddef>
22
23#include "min_allocator.h"
24
25struct TemplateConstructor
26{
27    template<typename T>
28    TemplateConstructor (const T&) {}
29};
30
31bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
32struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
33
34int main()
35{
36    {
37        typedef std::unordered_multimap<int, std::string> C;
38        typedef std::pair<int, std::string> P;
39        P a[] =
40        {
41            P(1, "one"),
42            P(2, "two"),
43            P(3, "three"),
44            P(4, "four"),
45            P(1, "four"),
46            P(2, "four"),
47        };
48        C c(a, a + sizeof(a)/sizeof(a[0]));
49        C::const_iterator i = c.find(2);
50        C::const_iterator i_next = i;
51        ++i_next;
52        C::iterator j = c.erase(i);
53        assert(j == i_next);
54
55        assert(c.size() == 5);
56        typedef std::pair<C::const_iterator, C::const_iterator> Eq;
57        Eq eq = c.equal_range(1);
58        assert(std::distance(eq.first, eq.second) == 2);
59        C::const_iterator k = eq.first;
60        assert(k->first == 1);
61        assert(k->second == "one");
62        ++k;
63        assert(k->first == 1);
64        assert(k->second == "four");
65        eq = c.equal_range(2);
66        assert(std::distance(eq.first, eq.second) == 1);
67        k = eq.first;
68        assert(k->first == 2);
69        assert(k->second == "four");
70        eq = c.equal_range(3);
71        assert(std::distance(eq.first, eq.second) == 1);
72        k = eq.first;
73        assert(k->first == 3);
74        assert(k->second == "three");
75        eq = c.equal_range(4);
76        assert(std::distance(eq.first, eq.second) == 1);
77        k = eq.first;
78        assert(k->first == 4);
79        assert(k->second == "four");
80        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
81        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
82    }
83#if TEST_STD_VER >= 11
84    {
85        typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
86                            min_allocator<std::pair<const int, std::string>>> C;
87        typedef std::pair<int, std::string> P;
88        P a[] =
89        {
90            P(1, "one"),
91            P(2, "two"),
92            P(3, "three"),
93            P(4, "four"),
94            P(1, "four"),
95            P(2, "four"),
96        };
97        C c(a, a + sizeof(a)/sizeof(a[0]));
98        C::const_iterator i = c.find(2);
99        C::const_iterator i_next = i;
100        ++i_next;
101        C::iterator j = c.erase(i);
102        assert(j == i_next);
103
104        assert(c.size() == 5);
105        typedef std::pair<C::const_iterator, C::const_iterator> Eq;
106        Eq eq = c.equal_range(1);
107        assert(std::distance(eq.first, eq.second) == 2);
108        C::const_iterator k = eq.first;
109        assert(k->first == 1);
110        assert(k->second == "one");
111        ++k;
112        assert(k->first == 1);
113        assert(k->second == "four");
114        eq = c.equal_range(2);
115        assert(std::distance(eq.first, eq.second) == 1);
116        k = eq.first;
117        assert(k->first == 2);
118        assert(k->second == "four");
119        eq = c.equal_range(3);
120        assert(std::distance(eq.first, eq.second) == 1);
121        k = eq.first;
122        assert(k->first == 3);
123        assert(k->second == "three");
124        eq = c.equal_range(4);
125        assert(std::distance(eq.first, eq.second) == 1);
126        k = eq.first;
127        assert(k->first == 4);
128        assert(k->second == "four");
129        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
130        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
131    }
132#endif
133#if TEST_STD_VER >= 14
134    {
135    //  This is LWG #2059
136        typedef TemplateConstructor T;
137        typedef std::unordered_multimap<T, int, Hash> C;
138        typedef C::iterator I;
139
140        C m;
141        T a{0};
142        I it = m.find(a);
143        if (it != m.end())
144            m.erase(it);
145    }
146#endif
147}
148