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 // <map>
11
12 // class multimap
13
14 // void swap(multimap& m);
15
16 #include <map>
17 #include <cassert>
18
19 #include "min_allocator.h"
20
main()21 int main()
22 {
23 typedef std::pair<const int, double> V;
24 {
25 typedef std::multimap<int, double> M;
26 {
27 V ar1[] =
28 {
29 };
30 V ar2[] =
31 {
32 };
33 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
34 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
35 M m1_save = m1;
36 M m2_save = m2;
37 m1.swap(m2);
38 assert(m1 == m2_save);
39 assert(m2 == m1_save);
40 }
41 {
42 V ar1[] =
43 {
44 };
45 V ar2[] =
46 {
47 V(5, 5),
48 V(6, 6),
49 V(7, 7),
50 V(8, 8),
51 V(9, 9),
52 V(10, 10),
53 V(11, 11),
54 V(12, 12)
55 };
56 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
57 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
58 M m1_save = m1;
59 M m2_save = m2;
60 m1.swap(m2);
61 assert(m1 == m2_save);
62 assert(m2 == m1_save);
63 }
64 {
65 V ar1[] =
66 {
67 V(1, 1),
68 V(2, 2),
69 V(3, 3),
70 V(4, 4)
71 };
72 V ar2[] =
73 {
74 };
75 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
76 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
77 M m1_save = m1;
78 M m2_save = m2;
79 m1.swap(m2);
80 assert(m1 == m2_save);
81 assert(m2 == m1_save);
82 }
83 {
84 V ar1[] =
85 {
86 V(1, 1),
87 V(2, 2),
88 V(3, 3),
89 V(4, 4)
90 };
91 V ar2[] =
92 {
93 V(5, 5),
94 V(6, 6),
95 V(7, 7),
96 V(8, 8),
97 V(9, 9),
98 V(10, 10),
99 V(11, 11),
100 V(12, 12)
101 };
102 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
103 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
104 M m1_save = m1;
105 M m2_save = m2;
106 m1.swap(m2);
107 assert(m1 == m2_save);
108 assert(m2 == m1_save);
109 }
110 }
111 #if __cplusplus >= 201103L
112 {
113 typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
114 {
115 V ar1[] =
116 {
117 };
118 V ar2[] =
119 {
120 };
121 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
122 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
123 M m1_save = m1;
124 M m2_save = m2;
125 m1.swap(m2);
126 assert(m1 == m2_save);
127 assert(m2 == m1_save);
128 }
129 {
130 V ar1[] =
131 {
132 };
133 V ar2[] =
134 {
135 V(5, 5),
136 V(6, 6),
137 V(7, 7),
138 V(8, 8),
139 V(9, 9),
140 V(10, 10),
141 V(11, 11),
142 V(12, 12)
143 };
144 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
145 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
146 M m1_save = m1;
147 M m2_save = m2;
148 m1.swap(m2);
149 assert(m1 == m2_save);
150 assert(m2 == m1_save);
151 }
152 {
153 V ar1[] =
154 {
155 V(1, 1),
156 V(2, 2),
157 V(3, 3),
158 V(4, 4)
159 };
160 V ar2[] =
161 {
162 };
163 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
164 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
165 M m1_save = m1;
166 M m2_save = m2;
167 m1.swap(m2);
168 assert(m1 == m2_save);
169 assert(m2 == m1_save);
170 }
171 {
172 V ar1[] =
173 {
174 V(1, 1),
175 V(2, 2),
176 V(3, 3),
177 V(4, 4)
178 };
179 V ar2[] =
180 {
181 V(5, 5),
182 V(6, 6),
183 V(7, 7),
184 V(8, 8),
185 V(9, 9),
186 V(10, 10),
187 V(11, 11),
188 V(12, 12)
189 };
190 M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
191 M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
192 M m1_save = m1;
193 M m2_save = m2;
194 m1.swap(m2);
195 assert(m1 == m2_save);
196 assert(m2 == m1_save);
197 }
198 }
199 #endif
200 }
201