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 // <map>
12 
13 // class map
14 
15 // map(map&& m);
16 
17 #include <map>
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     typedef std::pair<const int, double> V;
27     {
28         typedef test_compare<std::less<int> > C;
29         typedef test_allocator<V> A;
30         std::map<int, double, C, A> mo(C(5), A(7));
31         std::map<int, double, 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         V ar[] =
44         {
45             V(1, 1),
46             V(1, 1.5),
47             V(1, 2),
48             V(2, 1),
49             V(2, 1.5),
50             V(2, 2),
51             V(3, 1),
52             V(3, 1.5),
53             V(3, 2),
54         };
55         typedef test_compare<std::less<int> > C;
56         typedef test_allocator<V> A;
57         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
58         std::map<int, double, C, A> m = std::move(mo);
59         assert(m.get_allocator() == A(7));
60         assert(m.key_comp() == C(5));
61         assert(m.size() == 3);
62         assert(distance(m.begin(), m.end()) == 3);
63         assert(*m.begin() == V(1, 1));
64         assert(*next(m.begin()) == V(2, 1));
65         assert(*next(m.begin(), 2) == V(3, 1));
66 
67         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
68         assert(mo.key_comp() == C(5));
69         assert(mo.size() == 0);
70         assert(distance(mo.begin(), mo.end()) == 0);
71     }
72     {
73         typedef test_compare<std::less<int> > C;
74         typedef min_allocator<V> A;
75         std::map<int, double, C, A> mo(C(5), A());
76         std::map<int, double, C, A> m = std::move(mo);
77         assert(m.get_allocator() == A());
78         assert(m.key_comp() == C(5));
79         assert(m.size() == 0);
80         assert(distance(m.begin(), m.end()) == 0);
81 
82         assert(mo.get_allocator() == A());
83         assert(mo.key_comp() == C(5));
84         assert(mo.size() == 0);
85         assert(distance(mo.begin(), mo.end()) == 0);
86     }
87     {
88         V ar[] =
89         {
90             V(1, 1),
91             V(1, 1.5),
92             V(1, 2),
93             V(2, 1),
94             V(2, 1.5),
95             V(2, 2),
96             V(3, 1),
97             V(3, 1.5),
98             V(3, 2),
99         };
100         typedef test_compare<std::less<int> > C;
101         typedef min_allocator<V> A;
102         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
103         std::map<int, double, C, A> m = std::move(mo);
104         assert(m.get_allocator() == A());
105         assert(m.key_comp() == C(5));
106         assert(m.size() == 3);
107         assert(distance(m.begin(), m.end()) == 3);
108         assert(*m.begin() == V(1, 1));
109         assert(*next(m.begin()) == V(2, 1));
110         assert(*next(m.begin(), 2) == V(3, 1));
111 
112         assert(mo.get_allocator() == A());
113         assert(mo.key_comp() == C(5));
114         assert(mo.size() == 0);
115         assert(distance(mo.begin(), mo.end()) == 0);
116     }
117 
118   return 0;
119 }
120