llvm-project

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

29
template <class Map>
30
bool map_equal(const Map& map, Map other)
31
{
32
    return map == other;
33
}
34

35
#ifndef TEST_HAS_NO_EXCEPTIONS
36
struct throw_comparator
37
{
38
    bool& should_throw_;
39

40
    throw_comparator(bool& should_throw) : should_throw_(should_throw) {}
41

42
    template <class T>
43
    bool operator()(const T& lhs, const T& rhs) const
44
    {
45
        if (should_throw_)
46
            throw 0;
47
        return lhs < rhs;
48
    }
49
};
50
#endif
51

52
int main(int, char**)
53
{
54
    {
55
        std::multimap<int, int> src{{1, 0}, {3, 0}, {5, 0}};
56
        std::multimap<int, int> dst{{2, 0}, {4, 0}, {5, 0}};
57
        dst.merge(src);
58
        assert(map_equal(src, {}));
59
        assert(map_equal(dst, {{1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {5, 0}}));
60
    }
61

62
#ifndef TEST_HAS_NO_EXCEPTIONS
63
    {
64
        bool do_throw = false;
65
        typedef std::multimap<Counter<int>, int, throw_comparator> map_type;
66
        map_type src({{1, 0}, {3, 0}, {5, 0}}, throw_comparator(do_throw));
67
        map_type dst({{2, 0}, {4, 0}, {5, 0}}, throw_comparator(do_throw));
68

69
        assert(Counter_base::gConstructed == 6);
70

71
        do_throw = true;
72
        try
73
        {
74
            dst.merge(src);
75
        }
76
        catch (int)
77
        {
78
            do_throw = false;
79
        }
80
        assert(!do_throw);
81
        assert(map_equal(src, map_type({{1, 0}, {3, 0}, {5, 0}}, throw_comparator(do_throw))));
82
        assert(map_equal(dst, map_type({{2, 0}, {4, 0}, {5, 0}}, throw_comparator(do_throw))));
83
    }
84
#endif
85
    assert(Counter_base::gConstructed == 0);
86
    struct comparator
87
    {
88
        comparator() = default;
89

90
        bool operator()(const Counter<int>& lhs, const Counter<int>& rhs) const
91
        {
92
            return lhs < rhs;
93
        }
94
    };
95
    {
96
        typedef std::multimap<Counter<int>, int, std::less<Counter<int>>> first_map_type;
97
        typedef std::multimap<Counter<int>, int, comparator> second_map_type;
98
        typedef std::map<Counter<int>, int, comparator> third_map_type;
99

100
        {
101
            first_map_type first{{1, 0}, {2, 0}, {3, 0}};
102
            second_map_type second{{2, 0}, {3, 0}, {4, 0}};
103
            third_map_type third{{1, 0}, {3, 0}};
104

105
            assert(Counter_base::gConstructed == 8);
106

107
            first.merge(second);
108
            first.merge(third);
109

110
            assert(map_equal(first, {{1, 0}, {1, 0}, {2, 0}, {2, 0}, {3, 0}, {3, 0}, {3, 0}, {4, 0}}));
111
            assert(map_equal(second, {}));
112
            assert(map_equal(third, {}));
113

114
            assert(Counter_base::gConstructed == 8);
115
        }
116
        assert(Counter_base::gConstructed == 0);
117
        {
118
            first_map_type first{{1, 0}, {2, 0}, {3, 0}};
119
            second_map_type second{{2, 0}, {3, 0}, {4, 0}};
120
            third_map_type third{{1, 0}, {3, 0}};
121

122
            assert(Counter_base::gConstructed == 8);
123

124
            first.merge(std::move(second));
125
            first.merge(std::move(third));
126

127
            assert(map_equal(first, {{1, 0}, {1, 0}, {2, 0}, {2, 0}, {3, 0}, {3, 0}, {3, 0}, {4, 0}}));
128
            assert(map_equal(second, {}));
129
            assert(map_equal(third, {}));
130

131
            assert(Counter_base::gConstructed == 8);
132
        }
133
        assert(Counter_base::gConstructed == 0);
134
    }
135
    assert(Counter_base::gConstructed == 0);
136
    {
137
        std::multimap<int, int> first;
138
        {
139
            std::multimap<int, int> second;
140
            first.merge(second);
141
            first.merge(std::move(second));
142
        }
143
        {
144
            std::multimap<int, int> second;
145
            first.merge(second);
146
            first.merge(std::move(second));
147
        }
148
    }
149
    return 0;
150
}
151