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, c++11, c++14
10
11// <map>
12
13// class multimap
14
15// template <class C2>
16// void merge(map<key_type, value_type, C2, allocator_type>& source);
17// template <class C2>
18// void merge(map<key_type, value_type, C2, allocator_type>&& source);
19// template <class C2>
20// void merge(multimap<key_type, value_type, C2, allocator_type>& source);
21// template <class C2>
22// void merge(multimap<key_type, value_type, C2, allocator_type>&& source);
23
24#include <map>
25#include <cassert>
26#include "test_macros.h"
27#include "Counter.h"
28
29template <class Map>
30bool map_equal(const Map& map, Map other) {
31 return map == other;
32}
33
34#ifndef TEST_HAS_NO_EXCEPTIONS
35struct throw_comparator {
36 bool& should_throw_;
37
38 throw_comparator(bool& should_throw) : should_throw_(should_throw) {}
39
40 template <class T>
41 bool operator()(const T& lhs, const T& rhs) const {
42 if (should_throw_)
43 throw 0;
44 return lhs < rhs;
45 }
46};
47#endif
48
49int main(int, char**) {
50 {
51 std::multimap<int, int> src{{1, 0}, {3, 0}, {5, 0}};
52 std::multimap<int, int> dst{{2, 0}, {4, 0}, {5, 0}};
53 dst.merge(source&: src);
54 assert(map_equal(src, {}));
55 assert(map_equal(dst, {{1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {5, 0}}));
56 }
57
58#ifndef TEST_HAS_NO_EXCEPTIONS
59 {
60 bool do_throw = false;
61 typedef std::multimap<Counter<int>, int, throw_comparator> map_type;
62 map_type src({{1, 0}, {3, 0}, {5, 0}}, throw_comparator(do_throw));
63 map_type dst({{2, 0}, {4, 0}, {5, 0}}, throw_comparator(do_throw));
64
65 assert(Counter_base::gConstructed == 6);
66
67 do_throw = true;
68 try {
69 dst.merge(src);
70 } catch (int) {
71 do_throw = false;
72 }
73 assert(!do_throw);
74 assert(map_equal(src, map_type({{1, 0}, {3, 0}, {5, 0}}, throw_comparator(do_throw))));
75 assert(map_equal(dst, map_type({{2, 0}, {4, 0}, {5, 0}}, throw_comparator(do_throw))));
76 }
77#endif
78 assert(Counter_base::gConstructed == 0);
79 struct comparator {
80 comparator() = default;
81
82 bool operator()(const Counter<int>& lhs, const Counter<int>& rhs) const { return lhs < rhs; }
83 };
84 {
85 typedef std::multimap<Counter<int>, int, std::less<Counter<int>>> first_map_type;
86 typedef std::multimap<Counter<int>, int, comparator> second_map_type;
87 typedef std::map<Counter<int>, int, comparator> third_map_type;
88
89 {
90 first_map_type first{{1, 0}, {2, 0}, {3, 0}};
91 second_map_type second{{2, 0}, {3, 0}, {4, 0}};
92 third_map_type third{{1, 0}, {3, 0}};
93
94 assert(Counter_base::gConstructed == 8);
95
96 first.merge(second);
97 first.merge(third);
98
99 assert(map_equal(first, {{1, 0}, {1, 0}, {2, 0}, {2, 0}, {3, 0}, {3, 0}, {3, 0}, {4, 0}}));
100 assert(map_equal(second, {}));
101 assert(map_equal(third, {}));
102
103 assert(Counter_base::gConstructed == 8);
104 }
105 assert(Counter_base::gConstructed == 0);
106 {
107 first_map_type first{{1, 0}, {2, 0}, {3, 0}};
108 second_map_type second{{2, 0}, {3, 0}, {4, 0}};
109 third_map_type third{{1, 0}, {3, 0}};
110
111 assert(Counter_base::gConstructed == 8);
112
113 first.merge(std::move(second));
114 first.merge(std::move(third));
115
116 assert(map_equal(first, {{1, 0}, {1, 0}, {2, 0}, {2, 0}, {3, 0}, {3, 0}, {3, 0}, {4, 0}}));
117 assert(map_equal(second, {}));
118 assert(map_equal(third, {}));
119
120 assert(Counter_base::gConstructed == 8);
121 }
122 assert(Counter_base::gConstructed == 0);
123 }
124 assert(Counter_base::gConstructed == 0);
125 {
126 std::multimap<int, int> first;
127 {
128 std::multimap<int, int> second;
129 first.merge(source&: second);
130 first.merge(source: std::move(second));
131 }
132 {
133 std::multimap<int, int> second;
134 first.merge(source&: second);
135 first.merge(source: std::move(second));
136 }
137 }
138 return 0;
139}
140

source code of libcxx/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp