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// size_type erase(const key_type& k);
17
18#include <unordered_map>
19#include <string>
20#include <cassert>
21
22#include "min_allocator.h"
23
24#if __cplusplus >= 201103L
25template <typename Unordered>
26bool only_deletions ( const Unordered &whole, const Unordered &part ) {
27    typename Unordered::const_iterator w = whole.begin();
28    typename Unordered::const_iterator p = part.begin();
29
30    while ( w != whole.end () && p != part.end()) {
31        if ( *w == *p )
32            p++;
33        w++;
34        }
35
36    return p == part.end();
37}
38#endif
39
40
41int main()
42{
43    {
44        typedef std::unordered_map<int, std::string> C;
45        typedef std::pair<int, std::string> P;
46        P a[] =
47        {
48            P(1, "one"),
49            P(2, "two"),
50            P(3, "three"),
51            P(4, "four"),
52            P(1, "four"),
53            P(2, "four"),
54        };
55        C c(a, a + sizeof(a)/sizeof(a[0]));
56        assert(c.erase(5) == 0);
57        assert(c.size() == 4);
58        assert(c.at(1) == "one");
59        assert(c.at(2) == "two");
60        assert(c.at(3) == "three");
61        assert(c.at(4) == "four");
62
63        assert(c.erase(2) == 1);
64        assert(c.size() == 3);
65        assert(c.at(1) == "one");
66        assert(c.at(3) == "three");
67        assert(c.at(4) == "four");
68
69        assert(c.erase(2) == 0);
70        assert(c.size() == 3);
71        assert(c.at(1) == "one");
72        assert(c.at(3) == "three");
73        assert(c.at(4) == "four");
74
75        assert(c.erase(4) == 1);
76        assert(c.size() == 2);
77        assert(c.at(1) == "one");
78        assert(c.at(3) == "three");
79
80        assert(c.erase(4) == 0);
81        assert(c.size() == 2);
82        assert(c.at(1) == "one");
83        assert(c.at(3) == "three");
84
85        assert(c.erase(1) == 1);
86        assert(c.size() == 1);
87        assert(c.at(3) == "three");
88
89        assert(c.erase(1) == 0);
90        assert(c.size() == 1);
91        assert(c.at(3) == "three");
92
93        assert(c.erase(3) == 1);
94        assert(c.size() == 0);
95
96        assert(c.erase(3) == 0);
97        assert(c.size() == 0);
98    }
99#if __cplusplus >= 201103L
100    {
101        typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
102                            min_allocator<std::pair<const int, std::string>>> C;
103        typedef std::pair<int, std::string> P;
104        P a[] =
105        {
106            P(1, "one"),
107            P(2, "two"),
108            P(3, "three"),
109            P(4, "four"),
110            P(1, "four"),
111            P(2, "four"),
112        };
113        C c(a, a + sizeof(a)/sizeof(a[0]));
114        assert(c.erase(5) == 0);
115        assert(c.size() == 4);
116        assert(c.at(1) == "one");
117        assert(c.at(2) == "two");
118        assert(c.at(3) == "three");
119        assert(c.at(4) == "four");
120
121        assert(c.erase(2) == 1);
122        assert(c.size() == 3);
123        assert(c.at(1) == "one");
124        assert(c.at(3) == "three");
125        assert(c.at(4) == "four");
126
127        assert(c.erase(2) == 0);
128        assert(c.size() == 3);
129        assert(c.at(1) == "one");
130        assert(c.at(3) == "three");
131        assert(c.at(4) == "four");
132
133        assert(c.erase(4) == 1);
134        assert(c.size() == 2);
135        assert(c.at(1) == "one");
136        assert(c.at(3) == "three");
137
138        assert(c.erase(4) == 0);
139        assert(c.size() == 2);
140        assert(c.at(1) == "one");
141        assert(c.at(3) == "three");
142
143        assert(c.erase(1) == 1);
144        assert(c.size() == 1);
145        assert(c.at(3) == "three");
146
147        assert(c.erase(1) == 0);
148        assert(c.size() == 1);
149        assert(c.at(3) == "three");
150
151        assert(c.erase(3) == 1);
152        assert(c.size() == 0);
153
154        assert(c.erase(3) == 0);
155        assert(c.size() == 0);
156    }
157    {
158    typedef std::unordered_map<int, int> C;
159    C m, m2;
160    for ( int i = 0; i < 10; ++i ) {
161        m[i] = i;
162        m2[i] = i;
163        }
164
165    C::iterator i = m2.begin();
166    int ctr = 0;
167    while (i != m2.end()) {
168        if (ctr++ % 2 == 0)
169            m2.erase(i++);
170        else
171            ++i;
172        }
173
174    assert (only_deletions (m, m2));
175    }
176#endif
177}
178