]>
Commit | Line | Data |
---|---|---|
f7ace77f PC |
1 | // 2005-12-20 Paolo Carlini <pcarlini@suse.de> |
2 | ||
7adcbafe | 3 | // Copyright (C) 2005-2022 Free Software Foundation, Inc. |
f7ace77f PC |
4 | // |
5 | // This file is part of the GNU ISO C++ Library. This library is free | |
6 | // software; you can redistribute it and/or modify it under the | |
7 | // terms of the GNU General Public License as published by the | |
748086b7 | 8 | // Free Software Foundation; either version 3, or (at your option) |
f7ace77f PC |
9 | // any later version. |
10 | ||
11 | // This library is distributed in the hope that it will be useful, | |
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | // GNU General Public License for more details. | |
15 | ||
16 | // You should have received a copy of the GNU General Public License along | |
748086b7 JJ |
17 | // with this library; see the file COPYING3. If not see |
18 | // <http://www.gnu.org/licenses/>. | |
f7ace77f PC |
19 | |
20 | // 6.3.4.6 unordered_multimap::swap | |
21 | ||
22 | #include <tr1/unordered_map> | |
23 | #include <map> | |
24 | #include <testsuite_hooks.h> | |
25 | #include <testsuite_allocator.h> | |
26 | ||
27 | // uneq_allocator as a non-empty allocator. | |
28 | void | |
29 | test01() | |
30 | { | |
2df6377e DG |
31 | using namespace std::tr1; |
32 | using std::pair; | |
33 | using std::equal_to; | |
34 | using std::map; | |
35 | using std::multimap; | |
f7ace77f PC |
36 | |
37 | typedef pair<const char, int> my_pair; | |
38 | typedef __gnu_test::uneq_allocator<my_pair> my_alloc; | |
39 | typedef unordered_multimap<char, int, hash<char>, equal_to<char>, my_alloc> | |
40 | my_ummap; | |
f92ab29f | 41 | |
f7ace77f PC |
42 | const char title01[] = "Rivers of sand"; |
43 | const char title02[] = "Concret PH"; | |
44 | const char title03[] = "Sonatas and Interludes for Prepared Piano"; | |
45 | const char title04[] = "never as tired as when i'm waking up"; | |
46 | ||
47 | const size_t N1 = sizeof(title01); | |
48 | const size_t N2 = sizeof(title02); | |
49 | const size_t N3 = sizeof(title03); | |
50 | const size_t N4 = sizeof(title04); | |
51 | ||
52 | typedef multimap<char, int> my_mmap; | |
53 | my_mmap mmap01_ref; | |
54 | for (size_t i = 0; i < N1; ++i) | |
55 | mmap01_ref.insert(my_pair(title01[i], i)); | |
56 | my_mmap mmap02_ref; | |
57 | for (size_t i = 0; i < N2; ++i) | |
58 | mmap02_ref.insert(my_pair(title02[i], i)); | |
59 | my_mmap mmap03_ref; | |
60 | for (size_t i = 0; i < N3; ++i) | |
61 | mmap03_ref.insert(my_pair(title03[i], i)); | |
62 | my_mmap mmap04_ref; | |
63 | for (size_t i = 0; i < N4; ++i) | |
64 | mmap04_ref.insert(my_pair(title04[i], i)); | |
65 | ||
66 | typedef map<char, int> my_map; | |
67 | ||
68 | my_ummap::size_type size01, size02; | |
69 | ||
70 | my_alloc alloc01(1); | |
71 | ||
72 | my_ummap ummap01(10, hash<char>(), equal_to<char>(), alloc01); | |
73 | size01 = ummap01.size(); | |
74 | my_ummap ummap02(10, hash<char>(), equal_to<char>(), alloc01); | |
75 | size02 = ummap02.size(); | |
f92ab29f | 76 | |
f7ace77f PC |
77 | ummap01.swap(ummap02); |
78 | VERIFY( ummap01.size() == size02 ); | |
79 | VERIFY( ummap01.empty() ); | |
80 | VERIFY( ummap02.size() == size01 ); | |
81 | VERIFY( ummap02.empty() ); | |
82 | ||
83 | my_ummap ummap03(10, hash<char>(), equal_to<char>(), alloc01); | |
84 | size01 = ummap03.size(); | |
85 | my_ummap ummap04(mmap02_ref.begin(), mmap02_ref.end(), 10, hash<char>(), | |
86 | equal_to<char>(), alloc01); | |
87 | size02 = ummap04.size(); | |
88 | ||
89 | ummap03.swap(ummap04); | |
90 | VERIFY( ummap03.size() == size02 ); | |
91 | VERIFY( my_map(ummap03.begin(), ummap03.end()) | |
92 | == my_map(mmap02_ref.begin(), mmap02_ref.end()) ); | |
93 | VERIFY( ummap04.size() == size01 ); | |
94 | VERIFY( ummap04.empty() ); | |
f92ab29f | 95 | |
f7ace77f PC |
96 | my_ummap ummap05(mmap01_ref.begin(), mmap01_ref.end(), 10, hash<char>(), |
97 | equal_to<char>(), alloc01); | |
98 | size01 = ummap05.size(); | |
99 | my_ummap ummap06(mmap02_ref.begin(), mmap02_ref.end(), 10, hash<char>(), | |
100 | equal_to<char>(), alloc01); | |
101 | size02 = ummap06.size(); | |
102 | ||
103 | ummap05.swap(ummap06); | |
104 | VERIFY( ummap05.size() == size02 ); | |
105 | VERIFY( my_map(ummap05.begin(), ummap05.end()) | |
106 | == my_map(mmap02_ref.begin(), mmap02_ref.end()) ); | |
107 | VERIFY( ummap06.size() == size01 ); | |
108 | VERIFY( my_map(ummap06.begin(), ummap06.end()) | |
109 | == my_map(mmap01_ref.begin(), mmap01_ref.end()) ); | |
110 | ||
111 | my_ummap ummap07(mmap01_ref.begin(), mmap01_ref.end(), 10, hash<char>(), | |
112 | equal_to<char>(), alloc01); | |
113 | size01 = ummap07.size(); | |
114 | my_ummap ummap08(mmap03_ref.begin(), mmap03_ref.end(), 10, hash<char>(), | |
115 | equal_to<char>(), alloc01); | |
116 | size02 = ummap08.size(); | |
117 | ||
118 | ummap07.swap(ummap08); | |
119 | VERIFY( ummap07.size() == size02 ); | |
120 | VERIFY( my_map(ummap07.begin(), ummap07.end()) | |
121 | == my_map(mmap03_ref.begin(), mmap03_ref.end()) ); | |
122 | VERIFY( ummap08.size() == size01 ); | |
123 | VERIFY( my_map(ummap08.begin(), ummap08.end()) | |
124 | == my_map(mmap01_ref.begin(), mmap01_ref.end()) ); | |
125 | ||
126 | my_ummap ummap09(mmap03_ref.begin(), mmap03_ref.end(), 10, hash<char>(), | |
127 | equal_to<char>(), alloc01); | |
128 | size01 = ummap09.size(); | |
129 | my_ummap ummap10(mmap04_ref.begin(), mmap04_ref.end(), 10, hash<char>(), | |
130 | equal_to<char>(), alloc01); | |
131 | size02 = ummap10.size(); | |
132 | ||
133 | ummap09.swap(ummap10); | |
134 | VERIFY( ummap09.size() == size02 ); | |
135 | VERIFY( my_map(ummap09.begin(), ummap09.end()) | |
136 | == my_map(mmap04_ref.begin(), mmap04_ref.end()) ); | |
137 | VERIFY( ummap10.size() == size01 ); | |
138 | VERIFY( my_map(ummap10.begin(), ummap10.end()) | |
139 | == my_map(mmap03_ref.begin(), mmap03_ref.end()) ); | |
140 | ||
141 | my_ummap ummap11(mmap04_ref.begin(), mmap04_ref.end(), 10, hash<char>(), | |
142 | equal_to<char>(), alloc01); | |
143 | size01 = ummap11.size(); | |
144 | my_ummap ummap12(mmap01_ref.begin(), mmap01_ref.end(), 10, hash<char>(), | |
145 | equal_to<char>(), alloc01); | |
146 | size02 = ummap12.size(); | |
147 | ||
148 | ummap11.swap(ummap12); | |
149 | VERIFY( ummap11.size() == size02 ); | |
150 | VERIFY( my_map(ummap11.begin(), ummap11.end()) | |
151 | == my_map(mmap01_ref.begin(), mmap01_ref.end()) ); | |
152 | VERIFY( ummap12.size() == size01 ); | |
153 | VERIFY( my_map(ummap12.begin(), ummap12.end()) | |
154 | == my_map(mmap04_ref.begin(), mmap04_ref.end()) ); | |
155 | ||
156 | my_ummap ummap13(mmap03_ref.begin(), mmap03_ref.end(), 10, hash<char>(), | |
157 | equal_to<char>(), alloc01); | |
158 | size01 = ummap13.size(); | |
159 | my_ummap ummap14(mmap03_ref.begin(), mmap03_ref.end(), 10, hash<char>(), | |
160 | equal_to<char>(), alloc01); | |
161 | size02 = ummap14.size(); | |
162 | ||
163 | ummap13.swap(ummap14); | |
164 | VERIFY( ummap13.size() == size02 ); | |
165 | VERIFY( my_map(ummap13.begin(), ummap13.end()) | |
166 | == my_map(mmap03_ref.begin(), mmap03_ref.end()) ); | |
167 | VERIFY( ummap14.size() == size01 ); | |
168 | VERIFY( my_map(ummap14.begin(), ummap14.end()) | |
169 | == my_map(mmap03_ref.begin(), mmap03_ref.end()) ); | |
170 | } | |
171 | ||
172 | int main() | |
f92ab29f | 173 | { |
f7ace77f PC |
174 | test01(); |
175 | return 0; | |
176 | } |