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
// <set>
12

13
// class set
14

15
// set& operator=(set&& s);
16

17
#include <set>
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 MoveOnly V;
30
        typedef test_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_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
        LIBCPP_ASSERT(m1.empty());
105
    }
106
    {
107
        typedef MoveOnly V;
108
        typedef test_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_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
  return 0;
186
}
187