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 set
13
14// set(set&& s, const allocator_type& a);
15
16#include <set>
17#include <cassert>
18
19#include "../../../MoveOnly.h"
20#include "../../../test_compare.h"
21#include "test_allocator.h"
22
23int main()
24{
25#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
26    {
27        typedef MoveOnly V;
28        typedef test_compare<std::less<MoveOnly> > C;
29        typedef test_allocator<V> A;
30        typedef std::set<MoveOnly, C, A> M;
31        typedef std::move_iterator<V*> I;
32        V a1[] =
33        {
34            V(1),
35            V(1),
36            V(1),
37            V(2),
38            V(2),
39            V(2),
40            V(3),
41            V(3),
42            V(3)
43        };
44        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
45        V a2[] =
46        {
47            V(1),
48            V(1),
49            V(1),
50            V(2),
51            V(2),
52            V(2),
53            V(3),
54            V(3),
55            V(3)
56        };
57        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
58        M m3(std::move(m1), A(7));
59        assert(m3 == m2);
60        assert(m3.get_allocator() == A(7));
61        assert(m3.key_comp() == C(5));
62        assert(m1.empty());
63    }
64    {
65        typedef MoveOnly V;
66        typedef test_compare<std::less<MoveOnly> > C;
67        typedef test_allocator<V> A;
68        typedef std::set<MoveOnly, C, A> M;
69        typedef std::move_iterator<V*> I;
70        V a1[] =
71        {
72            V(1),
73            V(1),
74            V(1),
75            V(2),
76            V(2),
77            V(2),
78            V(3),
79            V(3),
80            V(3)
81        };
82        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
83        V a2[] =
84        {
85            V(1),
86            V(1),
87            V(1),
88            V(2),
89            V(2),
90            V(2),
91            V(3),
92            V(3),
93            V(3)
94        };
95        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
96        M m3(std::move(m1), A(5));
97        assert(m3 == m2);
98        assert(m3.get_allocator() == A(5));
99        assert(m3.key_comp() == C(5));
100        assert(m1.empty());
101    }
102    {
103        typedef MoveOnly V;
104        typedef test_compare<std::less<MoveOnly> > C;
105        typedef other_allocator<V> A;
106        typedef std::set<MoveOnly, C, A> M;
107        typedef std::move_iterator<V*> I;
108        V a1[] =
109        {
110            V(1),
111            V(1),
112            V(1),
113            V(2),
114            V(2),
115            V(2),
116            V(3),
117            V(3),
118            V(3)
119        };
120        M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
121        V a2[] =
122        {
123            V(1),
124            V(1),
125            V(1),
126            V(2),
127            V(2),
128            V(2),
129            V(3),
130            V(3),
131            V(3)
132        };
133        M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
134        M m3(std::move(m1), A(5));
135        assert(m3 == m2);
136        assert(m3.get_allocator() == A(5));
137        assert(m3.key_comp() == C(5));
138        assert(m1.empty());
139    }
140#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
141}
142