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