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// <map>
10
11// class map
12
13// template <class Key, class T, class Compare, class Allocator>
14// void
15// swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y);
16
17#include <map>
18#include <cassert>
19#include "test_macros.h"
20#include "test_allocator.h"
21#include "../../../test_compare.h"
22#include "min_allocator.h"
23
24int main(int, char**) {
25 typedef std::pair<const int, double> V;
26 {
27 typedef std::map<int, double> M;
28 {
29 M m1;
30 M m2;
31 M m1_save = m1;
32 M m2_save = m2;
33 swap(m1, m2);
34 assert(m1 == m2_save);
35 assert(m2 == m1_save);
36 }
37 {
38 V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
39 M m1;
40 M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
41 M m1_save = m1;
42 M m2_save = m2;
43 swap(m1, m2);
44 assert(m1 == m2_save);
45 assert(m2 == m1_save);
46 }
47 {
48 V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
49 M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
50 M m2;
51 M m1_save = m1;
52 M m2_save = m2;
53 swap(m1, m2);
54 assert(m1 == m2_save);
55 assert(m2 == m1_save);
56 }
57 {
58 V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
59 V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
60 M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
61 M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
62 M m1_save = m1;
63 M m2_save = m2;
64 swap(m1, m2);
65 assert(m1 == m2_save);
66 assert(m2 == m1_save);
67 }
68 }
69 {
70 typedef test_allocator<V> A;
71 typedef test_less<int> C;
72 typedef std::map<int, double, C, A> M;
73 V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
74 V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
75 M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]), C(1), A(1, 1));
76 M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]), C(2), A(1, 2));
77 M m1_save = m1;
78 M m2_save = m2;
79 swap(m1, m2);
80 assert(m1 == m2_save);
81 assert(m2 == m1_save);
82 assert(m1.key_comp() == C(2));
83 assert(m1.get_allocator().get_id() == 1); // not swapped
84 assert(m2.key_comp() == C(1));
85 assert(m2.get_allocator().get_id() == 2);
86 }
87 {
88 typedef other_allocator<V> A;
89 typedef test_less<int> C;
90 typedef std::map<int, double, C, A> M;
91 V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
92 V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
93 M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]), C(1), A(1));
94 M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]), C(2), A(2));
95 M m1_save = m1;
96 M m2_save = m2;
97 swap(m1, m2);
98 assert(m1 == m2_save);
99 assert(m2 == m1_save);
100 assert(m1.key_comp() == C(2));
101 assert(m1.get_allocator() == A(2));
102 assert(m2.key_comp() == C(1));
103 assert(m2.get_allocator() == A(1));
104 }
105#if TEST_STD_VER >= 11
106 {
107 typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
108 {
109 M m1;
110 M m2;
111 M m1_save = m1;
112 M m2_save = m2;
113 swap(m1, m2);
114 assert(m1 == m2_save);
115 assert(m2 == m1_save);
116 }
117 {
118 V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
119 M m1;
120 M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
121 M m1_save = m1;
122 M m2_save = m2;
123 swap(m1, m2);
124 assert(m1 == m2_save);
125 assert(m2 == m1_save);
126 }
127 {
128 V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
129 M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
130 M m2;
131 M m1_save = m1;
132 M m2_save = m2;
133 swap(m1, m2);
134 assert(m1 == m2_save);
135 assert(m2 == m1_save);
136 }
137 {
138 V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
139 V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
140 M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]));
141 M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]));
142 M m1_save = m1;
143 M m2_save = m2;
144 swap(m1, m2);
145 assert(m1 == m2_save);
146 assert(m2 == m1_save);
147 }
148 }
149 {
150 typedef min_allocator<V> A;
151 typedef test_less<int> C;
152 typedef std::map<int, double, C, A> M;
153 V ar1[] = {V(1, 1), V(2, 2), V(3, 3), V(4, 4)};
154 V ar2[] = {V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12)};
155 M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0]), C(1), A());
156 M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0]), C(2), A());
157 M m1_save = m1;
158 M m2_save = m2;
159 swap(m1, m2);
160 assert(m1 == m2_save);
161 assert(m2 == m1_save);
162 assert(m1.key_comp() == C(2));
163 assert(m1.get_allocator() == A());
164 assert(m2.key_comp() == C(1));
165 assert(m2.get_allocator() == A());
166 }
167#endif
168
169 return 0;
170}
171

source code of libcxx/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp