test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp

   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 // size_type erase(const key_type& k);
  17
  18 #include <unordered_map>
  19 #include <string>
  20 #include <cassert>
  21 #include <cstddef>
  22
  23 #include "min_allocator.h"
  24
  25 #if TEST_STD_VER >= 11
  26 template <typename Unordered>
  27 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
  28     typename Unordered::const_iterator w = whole.begin();
  29     typename Unordered::const_iterator p = part.begin();
  30
  31     while ( w != whole.end () && p != part.end()) {
  32         if ( *w == *p )
  33             p++;
  34         w++;
  35         }
  36
  37     return p == part.end();
  38 }
  39 #endif
  40
  41 int main()
  42 {
  43     {
  44         typedef std::unordered_multimap<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() == 6);
  58         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
  59         Eq eq = c.equal_range(1);
  60         assert(std::distance(eq.first, eq.second) == 2);
  61         C::const_iterator k = eq.first;
  62         assert(k->first == 1);
  63         assert(k->second == "one");
  64         ++k;
  65         assert(k->first == 1);
  66         assert(k->second == "four");
  67         eq = c.equal_range(2);
  68         assert(std::distance(eq.first, eq.second) == 2);
  69         k = eq.first;
  70         assert(k->first == 2);
  71         assert(k->second == "two");
  72         ++k;
  73         assert(k->first == 2);
  74         assert(k->second == "four");
  75         eq = c.equal_range(3);
  76         assert(std::distance(eq.first, eq.second) == 1);
  77         k = eq.first;
  78         assert(k->first == 3);
  79         assert(k->second == "three");
  80         eq = c.equal_range(4);
  81         assert(std::distance(eq.first, eq.second) == 1);
  82         k = eq.first;
  83         assert(k->first == 4);
  84         assert(k->second == "four");
  85         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
  86         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
  87
  88         assert(c.erase(2) == 2);
  89         assert(c.size() == 4);
  90         eq = c.equal_range(1);
  91         assert(std::distance(eq.first, eq.second) == 2);
  92         k = eq.first;
  93         assert(k->first == 1);
  94         assert(k->second == "one");
  95         ++k;
  96         assert(k->first == 1);
  97         assert(k->second == "four");
  98         eq = c.equal_range(3);
  99         assert(std::distance(eq.first, eq.second) == 1);
 100         k = eq.first;
 101         assert(k->first == 3);
 102         assert(k->second == "three");
 103         eq = c.equal_range(4);
 104         assert(std::distance(eq.first, eq.second) == 1);
 105         k = eq.first;
 106         assert(k->first == 4);
 107         assert(k->second == "four");
 108         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 109         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 110
 111         assert(c.erase(2) == 0);
 112         assert(c.size() == 4);
 113         eq = c.equal_range(1);
 114         assert(std::distance(eq.first, eq.second) == 2);
 115         k = eq.first;
 116         assert(k->first == 1);
 117         assert(k->second == "one");
 118         ++k;
 119         assert(k->first == 1);
 120         assert(k->second == "four");
 121         eq = c.equal_range(3);
 122         assert(std::distance(eq.first, eq.second) == 1);
 123         k = eq.first;
 124         assert(k->first == 3);
 125         assert(k->second == "three");
 126         eq = c.equal_range(4);
 127         assert(std::distance(eq.first, eq.second) == 1);
 128         k = eq.first;
 129         assert(k->first == 4);
 130         assert(k->second == "four");
 131         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 132         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 133
 134         assert(c.erase(4) == 1);
 135         assert(c.size() == 3);
 136         eq = c.equal_range(1);
 137         assert(std::distance(eq.first, eq.second) == 2);
 138         k = eq.first;
 139         assert(k->first == 1);
 140         assert(k->second == "one");
 141         ++k;
 142         assert(k->first == 1);
 143         assert(k->second == "four");
 144         eq = c.equal_range(3);
 145         assert(std::distance(eq.first, eq.second) == 1);
 146         k = eq.first;
 147         assert(k->first == 3);
 148         assert(k->second == "three");
 149         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 150         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 151
 152         assert(c.erase(4) == 0);
 153         assert(c.size() == 3);
 154         eq = c.equal_range(1);
 155         assert(std::distance(eq.first, eq.second) == 2);
 156         k = eq.first;
 157         assert(k->first == 1);
 158         assert(k->second == "one");
 159         ++k;
 160         assert(k->first == 1);
 161         assert(k->second == "four");
 162         eq = c.equal_range(3);
 163         assert(std::distance(eq.first, eq.second) == 1);
 164         k = eq.first;
 165         assert(k->first == 3);
 166         assert(k->second == "three");
 167         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 168         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 169
 170         assert(c.erase(1) == 2);
 171         assert(c.size() == 1);
 172         eq = c.equal_range(3);
 173         assert(std::distance(eq.first, eq.second) == 1);
 174         k = eq.first;
 175         assert(k->first == 3);
 176         assert(k->second == "three");
 177         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 178         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 179
 180         assert(c.erase(1) == 0);
 181         assert(c.size() == 1);
 182         eq = c.equal_range(3);
 183         assert(std::distance(eq.first, eq.second) == 1);
 184         k = eq.first;
 185         assert(k->first == 3);
 186         assert(k->second == "three");
 187         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 188         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 189
 190         assert(c.erase(3) == 1);
 191         assert(c.size() == 0);
 192         eq = c.equal_range(3);
 193         assert(std::distance(eq.first, eq.second) == 0);
 194         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 195         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 196
 197         assert(c.erase(3) == 0);
 198         assert(c.size() == 0);
 199         eq = c.equal_range(3);
 200         assert(std::distance(eq.first, eq.second) == 0);
 201         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 202         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 203     }
 204 #if TEST_STD_VER >= 11
 205     {
 206         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
 207                             min_allocator<std::pair<const int, std::string>>> C;
 208         typedef std::pair<int, std::string> P;
 209         P a[] =
 210         {
 211             P(1, "one"),
 212             P(2, "two"),
 213             P(3, "three"),
 214             P(4, "four"),
 215             P(1, "four"),
 216             P(2, "four"),
 217         };
 218         C c(a, a + sizeof(a)/sizeof(a[0]));
 219         assert(c.erase(5) == 0);
 220         assert(c.size() == 6);
 221         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
 222         Eq eq = c.equal_range(1);
 223         assert(std::distance(eq.first, eq.second) == 2);
 224         C::const_iterator k = eq.first;
 225         assert(k->first == 1);
 226         assert(k->second == "one");
 227         ++k;
 228         assert(k->first == 1);
 229         assert(k->second == "four");
 230         eq = c.equal_range(2);
 231         assert(std::distance(eq.first, eq.second) == 2);
 232         k = eq.first;
 233         assert(k->first == 2);
 234         assert(k->second == "two");
 235         ++k;
 236         assert(k->first == 2);
 237         assert(k->second == "four");
 238         eq = c.equal_range(3);
 239         assert(std::distance(eq.first, eq.second) == 1);
 240         k = eq.first;
 241         assert(k->first == 3);
 242         assert(k->second == "three");
 243         eq = c.equal_range(4);
 244         assert(std::distance(eq.first, eq.second) == 1);
 245         k = eq.first;
 246         assert(k->first == 4);
 247         assert(k->second == "four");
 248         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 249         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 250
 251         assert(c.erase(2) == 2);
 252         assert(c.size() == 4);
 253         eq = c.equal_range(1);
 254         assert(std::distance(eq.first, eq.second) == 2);
 255         k = eq.first;
 256         assert(k->first == 1);
 257         assert(k->second == "one");
 258         ++k;
 259         assert(k->first == 1);
 260         assert(k->second == "four");
 261         eq = c.equal_range(3);
 262         assert(std::distance(eq.first, eq.second) == 1);
 263         k = eq.first;
 264         assert(k->first == 3);
 265         assert(k->second == "three");
 266         eq = c.equal_range(4);
 267         assert(std::distance(eq.first, eq.second) == 1);
 268         k = eq.first;
 269         assert(k->first == 4);
 270         assert(k->second == "four");
 271         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 272         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 273
 274         assert(c.erase(2) == 0);
 275         assert(c.size() == 4);
 276         eq = c.equal_range(1);
 277         assert(std::distance(eq.first, eq.second) == 2);
 278         k = eq.first;
 279         assert(k->first == 1);
 280         assert(k->second == "one");
 281         ++k;
 282         assert(k->first == 1);
 283         assert(k->second == "four");
 284         eq = c.equal_range(3);
 285         assert(std::distance(eq.first, eq.second) == 1);
 286         k = eq.first;
 287         assert(k->first == 3);
 288         assert(k->second == "three");
 289         eq = c.equal_range(4);
 290         assert(std::distance(eq.first, eq.second) == 1);
 291         k = eq.first;
 292         assert(k->first == 4);
 293         assert(k->second == "four");
 294         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 295         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 296
 297         assert(c.erase(4) == 1);
 298         assert(c.size() == 3);
 299         eq = c.equal_range(1);
 300         assert(std::distance(eq.first, eq.second) == 2);
 301         k = eq.first;
 302         assert(k->first == 1);
 303         assert(k->second == "one");
 304         ++k;
 305         assert(k->first == 1);
 306         assert(k->second == "four");
 307         eq = c.equal_range(3);
 308         assert(std::distance(eq.first, eq.second) == 1);
 309         k = eq.first;
 310         assert(k->first == 3);
 311         assert(k->second == "three");
 312         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 313         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 314
 315         assert(c.erase(4) == 0);
 316         assert(c.size() == 3);
 317         eq = c.equal_range(1);
 318         assert(std::distance(eq.first, eq.second) == 2);
 319         k = eq.first;
 320         assert(k->first == 1);
 321         assert(k->second == "one");
 322         ++k;
 323         assert(k->first == 1);
 324         assert(k->second == "four");
 325         eq = c.equal_range(3);
 326         assert(std::distance(eq.first, eq.second) == 1);
 327         k = eq.first;
 328         assert(k->first == 3);
 329         assert(k->second == "three");
 330         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 331         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 332
 333         assert(c.erase(1) == 2);
 334         assert(c.size() == 1);
 335         eq = c.equal_range(3);
 336         assert(std::distance(eq.first, eq.second) == 1);
 337         k = eq.first;
 338         assert(k->first == 3);
 339         assert(k->second == "three");
 340         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 341         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 342
 343         assert(c.erase(1) == 0);
 344         assert(c.size() == 1);
 345         eq = c.equal_range(3);
 346         assert(std::distance(eq.first, eq.second) == 1);
 347         k = eq.first;
 348         assert(k->first == 3);
 349         assert(k->second == "three");
 350         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 351         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 352
 353         assert(c.erase(3) == 1);
 354         assert(c.size() == 0);
 355         eq = c.equal_range(3);
 356         assert(std::distance(eq.first, eq.second) == 0);
 357         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 358         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 359
 360         assert(c.erase(3) == 0);
 361         assert(c.size() == 0);
 362         eq = c.equal_range(3);
 363         assert(std::distance(eq.first, eq.second) == 0);
 364         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
 365         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 366     }
 367     {
 368     typedef std::unordered_multimap<int, int> C;
 369     C m, m2;
 370     for ( int i = 0; i < 10; ++i ) {
 371         for (int j = 0; j < 2; ++j ) {
 372             m.insert (std::make_pair(i,j));
 373             m2.insert(std::make_pair(i,j));
 374             }
 375         }
 376
 377     C::iterator i = m2.begin();
 378     int ctr = 0;
 379     while (i != m2.end()) {
 380         if (ctr++ % 2 == 0)
 381             m2.erase(i++);
 382         else
 383             ++i;
 384         }
 385
 386     assert (only_deletions (m, m2));
 387     }
 388 #endif
 389 }