1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <map>
11
12// class multimap
13
14// multimap& operator=(multimap&& m);
15
16#include <map>
17#include <cassert>
18
19#include "../../../MoveOnly.h"
20#include "../../../test_compare.h"
21#include "test_allocator.h"
22#include "min_allocator.h"
23
24int main()
25{
26#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
27    {
28        typedef std::pair<MoveOnly, MoveOnly> V;
29        typedef std::pair<const MoveOnly, MoveOnly> VC;
30        typedef test_compare<std::less<MoveOnly> > C;
31        typedef test_allocator<VC> A;
32        typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
33        typedef std::move_iterator<V*> I;
34        V a1[] =
35        {
36            V(1, 1),
37            V(1, 2),
38            V(1, 3),
39            V(2, 1),
40            V(2, 2),
41            V(2, 3),
42            V(3, 1),
43            V(3, 2),
44            V(3, 3)
45        };
46        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
47        V a2[] =
48        {
49            V(1, 1),
50            V(1, 2),
51            V(1, 3),
52            V(2, 1),
53            V(2, 2),
54            V(2, 3),
55            V(3, 1),
56            V(3, 2),
57            V(3, 3)
58        };
59        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
60        M m3(C(3), A(7));
61        m3 = std::move(m1);
62        assert(m3 == m2);
63        assert(m3.get_allocator() == A(7));
64        assert(m3.key_comp() == C(5));
65        assert(m1.empty());
66    }
67    {
68        typedef std::pair<MoveOnly, MoveOnly> V;
69        typedef std::pair<const MoveOnly, MoveOnly> VC;
70        typedef test_compare<std::less<MoveOnly> > C;
71        typedef test_allocator<VC> A;
72        typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
73        typedef std::move_iterator<V*> I;
74        V a1[] =
75        {
76            V(1, 1),
77            V(1, 2),
78            V(1, 3),
79            V(2, 1),
80            V(2, 2),
81            V(2, 3),
82            V(3, 1),
83            V(3, 2),
84            V(3, 3)
85        };
86        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
87        V a2[] =
88        {
89            V(1, 1),
90            V(1, 2),
91            V(1, 3),
92            V(2, 1),
93            V(2, 2),
94            V(2, 3),
95            V(3, 1),
96            V(3, 2),
97            V(3, 3)
98        };
99        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
100        M m3(C(3), A(5));
101        m3 = std::move(m1);
102        assert(m3 == m2);
103        assert(m3.get_allocator() == A(5));
104        assert(m3.key_comp() == C(5));
105        assert(m1.empty());
106    }
107    {
108        typedef std::pair<MoveOnly, MoveOnly> V;
109        typedef std::pair<const MoveOnly, MoveOnly> VC;
110        typedef test_compare<std::less<MoveOnly> > C;
111        typedef other_allocator<VC> A;
112        typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
113        typedef std::move_iterator<V*> I;
114        V a1[] =
115        {
116            V(1, 1),
117            V(1, 2),
118            V(1, 3),
119            V(2, 1),
120            V(2, 2),
121            V(2, 3),
122            V(3, 1),
123            V(3, 2),
124            V(3, 3)
125        };
126        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
127        V a2[] =
128        {
129            V(1, 1),
130            V(1, 2),
131            V(1, 3),
132            V(2, 1),
133            V(2, 2),
134            V(2, 3),
135            V(3, 1),
136            V(3, 2),
137            V(3, 3)
138        };
139        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
140        M m3(C(3), A(5));
141        m3 = std::move(m1);
142        assert(m3 == m2);
143        assert(m3.get_allocator() == A(7));
144        assert(m3.key_comp() == C(5));
145        assert(m1.empty());
146    }
147#if __cplusplus >= 201103L
148    {
149        typedef std::pair<MoveOnly, MoveOnly> V;
150        typedef std::pair<const MoveOnly, MoveOnly> VC;
151        typedef test_compare<std::less<MoveOnly> > C;
152        typedef min_allocator<VC> A;
153        typedef std::multimap<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#endif
189#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
190}
191