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++98, 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 "../../../Emplaceable.h" 22 #include "DefaultOnly.h" 23 #include "min_allocator.h" 24 25 int main(int, char**) 26 { 27 { 28 typedef std::multimap<int, DefaultOnly> M; 29 typedef M::iterator R; 30 M m; 31 assert(DefaultOnly::count == 0); 32 R r = m.emplace(); 33 assert(r == m.begin()); 34 assert(m.size() == 1); 35 assert(m.begin()->first == 0); 36 assert(m.begin()->second == DefaultOnly()); 37 assert(DefaultOnly::count == 1); 38 r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), 39 std::forward_as_tuple()); 40 assert(r == next(m.begin())); 41 assert(m.size() == 2); 42 assert(next(m.begin())->first == 1); 43 assert(next(m.begin())->second == DefaultOnly()); 44 assert(DefaultOnly::count == 2); 45 r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), 46 std::forward_as_tuple()); 47 assert(r == next(m.begin(), 2)); 48 assert(m.size() == 3); 49 assert(next(m.begin(), 2)->first == 1); 50 assert(next(m.begin(), 2)->second == DefaultOnly()); 51 assert(DefaultOnly::count == 3); 52 } 53 assert(DefaultOnly::count == 0); 54 { 55 typedef std::multimap<int, Emplaceable> M; 56 typedef M::iterator R; 57 M m; 58 R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), 59 std::forward_as_tuple()); 60 assert(r == m.begin()); 61 assert(m.size() == 1); 62 assert(m.begin()->first == 2); 63 assert(m.begin()->second == Emplaceable()); 64 r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), 65 std::forward_as_tuple(2, 3.5)); 66 assert(r == m.begin()); 67 assert(m.size() == 2); 68 assert(m.begin()->first == 1); 69 assert(m.begin()->second == Emplaceable(2, 3.5)); 70 r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), 71 std::forward_as_tuple(3, 3.5)); 72 assert(r == next(m.begin())); 73 assert(m.size() == 3); 74 assert(r->first == 1); 75 assert(r->second == Emplaceable(3, 3.5)); 76 } 77 { 78 typedef std::multimap<int, double> M; 79 typedef M::iterator R; 80 M m; 81 R r = m.emplace(M::value_type(2, 3.5)); 82 assert(r == m.begin()); 83 assert(m.size() == 1); 84 assert(m.begin()->first == 2); 85 assert(m.begin()->second == 3.5); 86 } 87 { 88 typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M; 89 typedef M::iterator R; 90 M m; 91 assert(DefaultOnly::count == 0); 92 R r = m.emplace(); 93 assert(r == m.begin()); 94 assert(m.size() == 1); 95 assert(m.begin()->first == 0); 96 assert(m.begin()->second == DefaultOnly()); 97 assert(DefaultOnly::count == 1); 98 r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), 99 std::forward_as_tuple()); 100 assert(r == next(m.begin())); 101 assert(m.size() == 2); 102 assert(next(m.begin())->first == 1); 103 assert(next(m.begin())->second == DefaultOnly()); 104 assert(DefaultOnly::count == 2); 105 r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), 106 std::forward_as_tuple()); 107 assert(r == next(m.begin(), 2)); 108 assert(m.size() == 3); 109 assert(next(m.begin(), 2)->first == 1); 110 assert(next(m.begin(), 2)->second == DefaultOnly()); 111 assert(DefaultOnly::count == 3); 112 } 113 assert(DefaultOnly::count == 0); 114 { 115 typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M; 116 typedef M::iterator R; 117 M m; 118 R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), 119 std::forward_as_tuple()); 120 assert(r == m.begin()); 121 assert(m.size() == 1); 122 assert(m.begin()->first == 2); 123 assert(m.begin()->second == Emplaceable()); 124 r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), 125 std::forward_as_tuple(2, 3.5)); 126 assert(r == m.begin()); 127 assert(m.size() == 2); 128 assert(m.begin()->first == 1); 129 assert(m.begin()->second == Emplaceable(2, 3.5)); 130 r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), 131 std::forward_as_tuple(3, 3.5)); 132 assert(r == next(m.begin())); 133 assert(m.size() == 3); 134 assert(r->first == 1); 135 assert(r->second == Emplaceable(3, 3.5)); 136 } 137 { 138 typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; 139 typedef M::iterator R; 140 M m; 141 R r = m.emplace(M::value_type(2, 3.5)); 142 assert(r == m.begin()); 143 assert(m.size() == 1); 144 assert(m.begin()->first == 2); 145 assert(m.begin()->second == 3.5); 146 } 147 148 return 0; 149 } 150