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 map
13
14// void swap(map& m);
15
16#include <map>
17#include <cassert>
18
19#include "min_allocator.h"
20
21int main()
22{
23    {
24    typedef std::pair<const int, double> V;
25    typedef std::map<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::pair<const int, double> V;
114    typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
115    {
116        V ar1[] =
117        {
118        };
119        V ar2[] =
120        {
121        };
122        M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
123        M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
124        M m1_save = m1;
125        M m2_save = m2;
126        m1.swap(m2);
127        assert(m1 == m2_save);
128        assert(m2 == m1_save);
129    }
130    {
131        V ar1[] =
132        {
133        };
134        V ar2[] =
135        {
136            V(5, 5),
137            V(6, 6),
138            V(7, 7),
139            V(8, 8),
140            V(9, 9),
141            V(10, 10),
142            V(11, 11),
143            V(12, 12)
144        };
145        M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
146        M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
147        M m1_save = m1;
148        M m2_save = m2;
149        m1.swap(m2);
150        assert(m1 == m2_save);
151        assert(m2 == m1_save);
152    }
153    {
154        V ar1[] =
155        {
156            V(1, 1),
157            V(2, 2),
158            V(3, 3),
159            V(4, 4)
160        };
161        V ar2[] =
162        {
163        };
164        M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
165        M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
166        M m1_save = m1;
167        M m2_save = m2;
168        m1.swap(m2);
169        assert(m1 == m2_save);
170        assert(m2 == m1_save);
171    }
172    {
173        V ar1[] =
174        {
175            V(1, 1),
176            V(2, 2),
177            V(3, 3),
178            V(4, 4)
179        };
180        V ar2[] =
181        {
182            V(5, 5),
183            V(6, 6),
184            V(7, 7),
185            V(8, 8),
186            V(9, 9),
187            V(10, 10),
188            V(11, 11),
189            V(12, 12)
190        };
191        M m1(ar1, ar1+sizeof(ar1)/sizeof(ar1[0]));
192        M m2(ar2, ar2+sizeof(ar2)/sizeof(ar2[0]));
193        M m1_save = m1;
194        M m2_save = m2;
195        m1.swap(m2);
196        assert(m1 == m2_save);
197        assert(m2 == m1_save);
198    }
199    }
200#endif
201}
202