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++98, c++03
10 
11 // <set>
12 
13 // class set
14 
15 // set(set&& s);
16 
17 #include <set>
18 #include <cassert>
19 
20 #include "../../../test_compare.h"
21 #include "test_allocator.h"
22 #include "min_allocator.h"
23 
24 int main(int, char**)
25 {
26     {
27         typedef int V;
28         typedef test_compare<std::less<int> > C;
29         typedef test_allocator<V> A;
30         std::set<int, C, A> mo(C(5), A(7));
31         std::set<int, C, A> m = std::move(mo);
32         assert(m.get_allocator() == A(7));
33         assert(m.key_comp() == C(5));
34         assert(m.size() == 0);
35         assert(distance(m.begin(), m.end()) == 0);
36 
37         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
38         assert(mo.key_comp() == C(5));
39         assert(mo.size() == 0);
40         assert(distance(mo.begin(), mo.end()) == 0);
41     }
42     {
43         typedef int V;
44         V ar[] =
45         {
46             1,
47             1,
48             1,
49             2,
50             2,
51             2,
52             3,
53             3,
54             3
55         };
56         typedef test_compare<std::less<int> > C;
57         typedef test_allocator<V> A;
58         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
59         std::set<int, C, A> m = std::move(mo);
60         assert(m.get_allocator() == A(7));
61         assert(m.key_comp() == C(5));
62         assert(m.size() == 3);
63         assert(distance(m.begin(), m.end()) == 3);
64         assert(*m.begin() == 1);
65         assert(*next(m.begin()) == 2);
66         assert(*next(m.begin(), 2) == 3);
67 
68         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
69         assert(mo.key_comp() == C(5));
70         assert(mo.size() == 0);
71         assert(distance(mo.begin(), mo.end()) == 0);
72     }
73     {
74         typedef int V;
75         V ar[] =
76         {
77             1,
78             1,
79             1,
80             2,
81             2,
82             2,
83             3,
84             3,
85             3
86         };
87         typedef test_compare<std::less<int> > C;
88         typedef min_allocator<V> A;
89         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
90         std::set<int, C, A> m = std::move(mo);
91         assert(m.get_allocator() == A());
92         assert(m.key_comp() == C(5));
93         assert(m.size() == 3);
94         assert(distance(m.begin(), m.end()) == 3);
95         assert(*m.begin() == 1);
96         assert(*next(m.begin()) == 2);
97         assert(*next(m.begin(), 2) == 3);
98 
99         assert(mo.get_allocator() == A());
100         assert(mo.key_comp() == C(5));
101         assert(mo.size() == 0);
102         assert(distance(mo.begin(), mo.end()) == 0);
103     }
104 
105   return 0;
106 }
107