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