libcxx/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03
  10
  11 // <map>
  12
  13 // class multimap
  14
  15 // template <class... Args>
  16 //   iterator emplace(Args&&... args);
  17
  18 #include <map>
  19 #include <cassert>
  20
  21 #include "test_macros.h"
  22 #include "../../../Emplaceable.h"
  23 #include "DefaultOnly.h"
  24 #include "min_allocator.h"
  25
  26 int main(int, char**)
  27 {
  28     {
  29         typedef std::multimap<int, DefaultOnly> M;
  30         typedef M::iterator R;
  31         M m;
  32         assert(DefaultOnly::count == 0);
  33         R r = m.emplace();
  34         assert(r == m.begin());
  35         assert(m.size() == 1);
  36         assert(m.begin()->first == 0);
  37         assert(m.begin()->second == DefaultOnly());
  38         assert(DefaultOnly::count == 1);
  39         r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
  40                                                 std::forward_as_tuple());
  41         assert(r == std::next(m.begin()));
  42         assert(m.size() == 2);
  43         assert(std::next(m.begin())->first == 1);
  44         assert(std::next(m.begin())->second == DefaultOnly());
  45         assert(DefaultOnly::count == 2);
  46         r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
  47                                                 std::forward_as_tuple());
  48         assert(r == std::next(m.begin(), 2));
  49         assert(m.size() == 3);
  50         assert(std::next(m.begin(), 2)->first == 1);
  51         assert(std::next(m.begin(), 2)->second == DefaultOnly());
  52         assert(DefaultOnly::count == 3);
  53     }
  54     assert(DefaultOnly::count == 0);
  55     {
  56         typedef std::multimap<int, Emplaceable> M;
  57         typedef M::iterator R;
  58         M m;
  59         R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2),
  60                                                   std::forward_as_tuple());
  61         assert(r == m.begin());
  62         assert(m.size() == 1);
  63         assert(m.begin()->first == 2);
  64         assert(m.begin()->second == Emplaceable());
  65         r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
  66                                                 std::forward_as_tuple(2, 3.5));
  67         assert(r == m.begin());
  68         assert(m.size() == 2);
  69         assert(m.begin()->first == 1);
  70         assert(m.begin()->second == Emplaceable(2, 3.5));
  71         r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
  72                                                 std::forward_as_tuple(3, 3.5));
  73         assert(r == std::next(m.begin()));
  74         assert(m.size() == 3);
  75         assert(r->first == 1);
  76         assert(r->second == Emplaceable(3, 3.5));
  77     }
  78     {
  79         typedef std::multimap<int, double> M;
  80         typedef M::iterator R;
  81         M m;
  82         R r = m.emplace(M::value_type(2, 3.5));
  83         assert(r == m.begin());
  84         assert(m.size() == 1);
  85         assert(m.begin()->first == 2);
  86         assert(m.begin()->second == 3.5);
  87     }
  88     {
  89         typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
  90         typedef M::iterator R;
  91         M m;
  92         assert(DefaultOnly::count == 0);
  93         R r = m.emplace();
  94         assert(r == m.begin());
  95         assert(m.size() == 1);
  96         assert(m.begin()->first == 0);
  97         assert(m.begin()->second == DefaultOnly());
  98         assert(DefaultOnly::count == 1);
  99         r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
 100                                                 std::forward_as_tuple());
 101         assert(r == std::next(m.begin()));
 102         assert(m.size() == 2);
 103         assert(std::next(m.begin())->first == 1);
 104         assert(std::next(m.begin())->second == DefaultOnly());
 105         assert(DefaultOnly::count == 2);
 106         r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
 107                                                 std::forward_as_tuple());
 108         assert(r == std::next(m.begin(), 2));
 109         assert(m.size() == 3);
 110         assert(std::next(m.begin(), 2)->first == 1);
 111         assert(std::next(m.begin(), 2)->second == DefaultOnly());
 112         assert(DefaultOnly::count == 3);
 113     }
 114     assert(DefaultOnly::count == 0);
 115     {
 116         typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M;
 117         typedef M::iterator R;
 118         M m;
 119         R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2),
 120                                                   std::forward_as_tuple());
 121         assert(r == m.begin());
 122         assert(m.size() == 1);
 123         assert(m.begin()->first == 2);
 124         assert(m.begin()->second == Emplaceable());
 125         r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
 126                                                 std::forward_as_tuple(2, 3.5));
 127         assert(r == m.begin());
 128         assert(m.size() == 2);
 129         assert(m.begin()->first == 1);
 130         assert(m.begin()->second == Emplaceable(2, 3.5));
 131         r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
 132                                                 std::forward_as_tuple(3, 3.5));
 133         assert(r == std::next(m.begin()));
 134         assert(m.size() == 3);
 135         assert(r->first == 1);
 136         assert(r->second == Emplaceable(3, 3.5));
 137     }
 138     {
 139         typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
 140         typedef M::iterator R;
 141         M m;
 142         R r = m.emplace(M::value_type(2, 3.5));
 143         assert(r == m.begin());
 144         assert(m.size() == 1);
 145         assert(m.begin()->first == 2);
 146         assert(m.begin()->second == 3.5);
 147     }
 148
 149   return 0;
 150 }