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