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
10

11
// <map>
12

13
// class map
14

15
// map& operator=(map&& m);
16

17
#include <map>
18
#include <cassert>
19

20
#include "test_macros.h"
21
#include "MoveOnly.h"
22
#include "../../../test_compare.h"
23
#include "test_allocator.h"
24
#include "min_allocator.h"
25

26
int main(int, char**)
27
{
28
    {
29
        typedef std::pair<MoveOnly, MoveOnly> V;
30
        typedef std::pair<const MoveOnly, MoveOnly> VC;
31
        typedef test_less<MoveOnly> C;
32
        typedef test_allocator<VC> A;
33
        typedef std::map<MoveOnly, MoveOnly, C, A> M;
34
        typedef std::move_iterator<V*> I;
35
        V a1[] =
36
        {
37
            V(1, 1),
38
            V(1, 2),
39
            V(1, 3),
40
            V(2, 1),
41
            V(2, 2),
42
            V(2, 3),
43
            V(3, 1),
44
            V(3, 2),
45
            V(3, 3)
46
        };
47
        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
48
        V a2[] =
49
        {
50
            V(1, 1),
51
            V(1, 2),
52
            V(1, 3),
53
            V(2, 1),
54
            V(2, 2),
55
            V(2, 3),
56
            V(3, 1),
57
            V(3, 2),
58
            V(3, 3)
59
        };
60
        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
61
        M m3(C(3), A(7));
62
        m3 = std::move(m1);
63
        assert(m3 == m2);
64
        assert(m3.get_allocator() == A(7));
65
        assert(m3.key_comp() == C(5));
66
        assert(m1.empty());
67
    }
68
    {
69
        typedef std::pair<MoveOnly, MoveOnly> V;
70
        typedef std::pair<const MoveOnly, MoveOnly> VC;
71
        typedef test_less<MoveOnly> C;
72
        typedef test_allocator<VC> A;
73
        typedef std::map<MoveOnly, MoveOnly, C, A> M;
74
        typedef std::move_iterator<V*> I;
75
        V a1[] =
76
        {
77
            V(1, 1),
78
            V(1, 2),
79
            V(1, 3),
80
            V(2, 1),
81
            V(2, 2),
82
            V(2, 3),
83
            V(3, 1),
84
            V(3, 2),
85
            V(3, 3)
86
        };
87
        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
88
        V a2[] =
89
        {
90
            V(1, 1),
91
            V(1, 2),
92
            V(1, 3),
93
            V(2, 1),
94
            V(2, 2),
95
            V(2, 3),
96
            V(3, 1),
97
            V(3, 2),
98
            V(3, 3)
99
        };
100
        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
101
        M m3(C(3), A(5));
102
        m3 = std::move(m1);
103
        assert(m3 == m2);
104
        assert(m3.get_allocator() == A(5));
105
        assert(m3.key_comp() == C(5));
106
        LIBCPP_ASSERT(m1.empty());
107
    }
108
    {
109
        typedef std::pair<MoveOnly, MoveOnly> V;
110
        typedef std::pair<const MoveOnly, MoveOnly> VC;
111
        typedef test_less<MoveOnly> C;
112
        typedef other_allocator<VC> A;
113
        typedef std::map<MoveOnly, MoveOnly, C, A> M;
114
        typedef std::move_iterator<V*> I;
115
        V a1[] =
116
        {
117
            V(1, 1),
118
            V(1, 2),
119
            V(1, 3),
120
            V(2, 1),
121
            V(2, 2),
122
            V(2, 3),
123
            V(3, 1),
124
            V(3, 2),
125
            V(3, 3)
126
        };
127
        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
128
        V a2[] =
129
        {
130
            V(1, 1),
131
            V(1, 2),
132
            V(1, 3),
133
            V(2, 1),
134
            V(2, 2),
135
            V(2, 3),
136
            V(3, 1),
137
            V(3, 2),
138
            V(3, 3)
139
        };
140
        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
141
        M m3(C(3), A(5));
142
        m3 = std::move(m1);
143
        assert(m3 == m2);
144
        assert(m3.get_allocator() == A(7));
145
        assert(m3.key_comp() == C(5));
146
        assert(m1.empty());
147
    }
148
    {
149
        typedef std::pair<MoveOnly, MoveOnly> V;
150
        typedef std::pair<const MoveOnly, MoveOnly> VC;
151
        typedef test_less<MoveOnly> C;
152
        typedef min_allocator<VC> A;
153
        typedef std::map<MoveOnly, MoveOnly, C, A> M;
154
        typedef std::move_iterator<V*> I;
155
        V a1[] =
156
        {
157
            V(1, 1),
158
            V(1, 2),
159
            V(1, 3),
160
            V(2, 1),
161
            V(2, 2),
162
            V(2, 3),
163
            V(3, 1),
164
            V(3, 2),
165
            V(3, 3)
166
        };
167
        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A());
168
        V a2[] =
169
        {
170
            V(1, 1),
171
            V(1, 2),
172
            V(1, 3),
173
            V(2, 1),
174
            V(2, 2),
175
            V(2, 3),
176
            V(3, 1),
177
            V(3, 2),
178
            V(3, 3)
179
        };
180
        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A());
181
        M m3(C(3), A());
182
        m3 = std::move(m1);
183
        assert(m3 == m2);
184
        assert(m3.get_allocator() == A());
185
        assert(m3.key_comp() == C(5));
186
        assert(m1.empty());
187
    }
188

189
  return 0;
190
}
191