test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.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 // UNSUPPORTED: c++98, c++03
  11
  12 // <unordered_map>
  13
  14 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
  15 //           class Alloc = allocator<pair<const Key, T>>>
  16 // class unordered_multimap
  17
  18 // template <class P,
  19 //           class = typename enable_if<is_convertible<P, value_type>::value>::type>
  20 //     iterator insert(const_iterator p, P&& x);
  21
  22 #if _LIBCPP_DEBUG >= 1
  23 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
  24 #endif
  25
  26 #include <unordered_map>
  27 #include <cassert>
  28
  29 #include "MoveOnly.h"
  30 #include "min_allocator.h"
  31
  32 int main()
  33 {
  34     {
  35         typedef std::unordered_multimap<double, int> C;
  36         typedef C::iterator R;
  37         typedef std::pair<double, short> P;
  38         C c;
  39         C::const_iterator e = c.end();
  40         R r = c.insert(e, P(3.5, static_cast<short>(3)));
  41         assert(c.size() == 1);
  42         assert(r->first == 3.5);
  43         assert(r->second == 3);
  44
  45         r = c.insert(r, P(3.5, static_cast<short>(4)));
  46         assert(c.size() == 2);
  47         assert(r->first == 3.5);
  48         assert(r->second == 4);
  49
  50         r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
  51         assert(c.size() == 3);
  52         assert(r->first == 4.5);
  53         assert(r->second == 4);
  54
  55         r = c.insert(c.end(), P(5.5, static_cast<short>(4)));
  56         assert(c.size() == 4);
  57         assert(r->first == 5.5);
  58         assert(r->second == 4);
  59     }
  60     {
  61         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
  62         typedef C::iterator R;
  63         typedef std::pair<MoveOnly, MoveOnly> P;
  64         C c;
  65         C::const_iterator e = c.end();
  66         R r = c.insert(e, P(3, 3));
  67         assert(c.size() == 1);
  68         assert(r->first == 3);
  69         assert(r->second == 3);
  70
  71         r = c.insert(r, P(3, 4));
  72         assert(c.size() == 2);
  73         assert(r->first == 3);
  74         assert(r->second == 4);
  75
  76         r = c.insert(c.end(), P(4, 4));
  77         assert(c.size() == 3);
  78         assert(r->first == 4);
  79         assert(r->second == 4);
  80
  81         r = c.insert(c.end(), P(5, 4));
  82         assert(c.size() == 4);
  83         assert(r->first == 5);
  84         assert(r->second == 4);
  85     }
  86     {
  87         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
  88                             min_allocator<std::pair<const double, int>>> C;
  89         typedef C::iterator R;
  90         typedef std::pair<double, short> P;
  91         C c;
  92         C::const_iterator e = c.end();
  93         R r = c.insert(e, P(3.5, static_cast<short>(3)));
  94         assert(c.size() == 1);
  95         assert(r->first == 3.5);
  96         assert(r->second == 3);
  97
  98         r = c.insert(r, P(3.5, static_cast<short>(4)));
  99         assert(c.size() == 2);
 100         assert(r->first == 3.5);
 101         assert(r->second == 4);
 102
 103         r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
 104         assert(c.size() == 3);
 105         assert(r->first == 4.5);
 106         assert(r->second == 4);
 107
 108         r = c.insert(c.end(), P(5.5, static_cast<short>(4)));
 109         assert(c.size() == 4);
 110         assert(r->first == 5.5);
 111         assert(r->second == 4);
 112     }
 113     {
 114         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
 115                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
 116         typedef C::iterator R;
 117         typedef std::pair<MoveOnly, MoveOnly> P;
 118         C c;
 119         C::const_iterator e = c.end();
 120         R r = c.insert(e, P(3, 3));
 121         assert(c.size() == 1);
 122         assert(r->first == 3);
 123         assert(r->second == 3);
 124
 125         r = c.insert(r, P(3, 4));
 126         assert(c.size() == 2);
 127         assert(r->first == 3);
 128         assert(r->second == 4);
 129
 130         r = c.insert(c.end(), P(4, 4));
 131         assert(c.size() == 3);
 132         assert(r->first == 4);
 133         assert(r->second == 4);
 134
 135         r = c.insert(c.end(), P(5, 4));
 136         assert(c.size() == 4);
 137         assert(r->first == 5);
 138         assert(r->second == 4);
 139     }
 140     {
 141         typedef std::unordered_multimap<double, int> C;
 142         typedef C::iterator R;
 143         C c;
 144         C::const_iterator e = c.end();
 145         R r = c.insert(e, {3.5, 3});
 146         assert(c.size() == 1);
 147         assert(r->first == 3.5);
 148         assert(r->second == 3);
 149
 150         r = c.insert(r, {3.5, 4});
 151         assert(c.size() == 2);
 152         assert(r->first == 3.5);
 153         assert(r->second == 4);
 154
 155         r = c.insert(c.end(), {4.5, 4});
 156         assert(c.size() == 3);
 157         assert(r->first == 4.5);
 158         assert(r->second == 4);
 159
 160         r = c.insert(c.end(), {5.5, 4});
 161         assert(c.size() == 4);
 162         assert(r->first == 5.5);
 163         assert(r->second == 4);
 164     }
 165 #if _LIBCPP_DEBUG >= 1
 166     {
 167         typedef std::unordered_multimap<double, int> C;
 168         typedef C::iterator R;
 169         typedef C::value_type P;
 170         C c;
 171         C c2;
 172         C::const_iterator e = c2.end();
 173         R r = c.insert(e, P(3.5, 3));
 174         assert(false);
 175     }
 176 #endif
 177 }