]>
Commit | Line | Data |
---|---|---|
aa118a03 | 1 | // Copyright (C) 2010-2014 Free Software Foundation, Inc. |
d7830142 FD |
2 | // |
3 | // This file is part of the GNU ISO C++ Library. This library is free | |
4 | // software; you can redistribute it and/or modify it under the | |
5 | // terms of the GNU General Public License as published by the | |
6 | // Free Software Foundation; either version 3, or (at your option) | |
7 | // any later version. | |
8 | // | |
9 | // This library is distributed in the hope that it will be useful, | |
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | // GNU General Public License for more details. | |
13 | // | |
14 | // You should have received a copy of the GNU General Public License along | |
15 | // with this library; see the file COPYING3. If not see | |
16 | // <http://www.gnu.org/licenses/>. | |
17 | // | |
18 | ||
19 | #include <vector> | |
20 | #include <deque> | |
21 | #include <list> | |
22 | #ifndef _GLIBCXX_DEBUG | |
23 | # include <debug/vector> | |
24 | # include <debug/deque> | |
25 | # include <debug/list> | |
26 | #endif | |
27 | #include <testsuite_hooks.h> | |
28 | ||
29 | namespace __gnu_test | |
30 | { | |
31 | template<typename _Tp> | |
32 | struct CopyableValueType | |
33 | { | |
34 | typedef _Tp value_type; | |
35 | }; | |
36 | ||
37 | template<typename _Tp1, typename _Tp2> | |
38 | struct CopyableValueType<std::pair<const _Tp1, _Tp2> > | |
39 | { | |
40 | typedef std::pair<_Tp1, _Tp2> value_type; | |
41 | }; | |
42 | ||
43 | template<typename _Tp> | |
44 | struct generate_unique | |
45 | { | |
46 | typedef _Tp value_type; | |
47 | ||
77e0bf4e | 48 | value_type build() |
d7830142 FD |
49 | { |
50 | static value_type _S_; | |
51 | ++_S_; | |
52 | return _S_; | |
53 | } | |
54 | }; | |
55 | ||
56 | template<typename _Tp1, typename _Tp2> | |
57 | struct generate_unique<std::pair<_Tp1, _Tp2> > | |
58 | { | |
59 | typedef _Tp1 first_type; | |
60 | typedef _Tp2 second_type; | |
61 | typedef std::pair<_Tp1, _Tp2> pair_type; | |
62 | ||
77e0bf4e | 63 | pair_type build() |
d7830142 FD |
64 | { |
65 | static first_type _S_1; | |
66 | static second_type _S_2; | |
67 | ++_S_1; | |
68 | ++_S_2; | |
69 | return pair_type(_S_1, _S_2); | |
70 | } | |
71 | }; | |
72 | ||
73 | // Check that invalid range of pointers is detected | |
74 | template<typename _Tp> | |
75 | void | |
76 | check_assign1() | |
77 | { | |
78 | bool test __attribute__((unused)) = true; | |
79 | ||
80 | typedef _Tp cont_type; | |
81 | typedef typename cont_type::value_type cont_val_type; | |
82 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
83 | typedef std::vector<val_type> vector_type; | |
84 | ||
85 | generate_unique<val_type> gu; | |
86 | ||
87 | vector_type v; | |
88 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 89 | v.push_back(gu.build()); |
d7830142 FD |
90 | VERIFY(v.size() == 5); |
91 | ||
92 | const val_type* first = &v.front() + 1; | |
93 | const val_type* last = first + 2; | |
94 | ||
95 | cont_type c1; | |
96 | c1.assign(first, last); | |
97 | VERIFY(c1.size() == 2); | |
98 | ||
99 | cont_type c2; | |
100 | c2.assign(last, first); // Expected failure | |
101 | } | |
102 | ||
103 | // Check that invalid range of debug random iterators is detected | |
104 | template<typename _Tp> | |
105 | void | |
106 | check_assign2() | |
107 | { | |
108 | bool test __attribute__((unused)) = true; | |
109 | ||
110 | typedef _Tp cont_type; | |
111 | typedef typename cont_type::value_type cont_val_type; | |
112 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
113 | typedef std::vector<val_type> vector_type; | |
114 | ||
115 | generate_unique<val_type> gu; | |
116 | ||
117 | vector_type v; | |
118 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 119 | v.push_back(gu.build()); |
d7830142 FD |
120 | VERIFY(v.size() == 5); |
121 | ||
122 | typename vector_type::iterator first = v.begin() + 1; | |
123 | typename vector_type::iterator last = first + 2; | |
124 | cont_type c1; | |
125 | c1.assign(first, last); | |
126 | VERIFY(c1.size() == 2); | |
127 | ||
128 | cont_type c2; | |
129 | c2.assign(last, first); // Expected failure | |
130 | } | |
131 | ||
5720787a | 132 | // Check that invalid range of debug not random iterators is detected |
d7830142 FD |
133 | template<typename _Tp> |
134 | void | |
135 | check_assign3() | |
136 | { | |
137 | bool test __attribute__((unused)) = true; | |
138 | ||
139 | typedef _Tp cont_type; | |
140 | typedef typename cont_type::value_type cont_val_type; | |
141 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
142 | typedef std::list<val_type> list_type; | |
143 | ||
144 | generate_unique<val_type> gu; | |
145 | ||
146 | list_type l; | |
147 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 148 | l.push_back(gu.build()); |
d7830142 FD |
149 | VERIFY(l.size() == 5); |
150 | ||
151 | typename list_type::iterator first = l.begin(); ++first; | |
152 | typename list_type::iterator last = first; ++last; ++last; | |
153 | cont_type c1; | |
154 | c1.assign(first, last); | |
155 | VERIFY(c1.size() == 2); | |
156 | ||
157 | cont_type c2; | |
158 | c2.assign(last, first); // Expected failure | |
159 | } | |
160 | ||
161 | // Check that invalid range of pointers is detected | |
162 | template<typename _Tp> | |
163 | void | |
164 | check_construct1() | |
165 | { | |
166 | bool test __attribute__((unused)) = true; | |
167 | ||
168 | typedef _Tp cont_type; | |
169 | typedef typename cont_type::value_type cont_val_type; | |
170 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
171 | typedef std::vector<val_type> vector_type; | |
172 | ||
173 | generate_unique<val_type> gu; | |
174 | ||
175 | vector_type v; | |
176 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 177 | v.push_back(gu.build()); |
d7830142 FD |
178 | VERIFY(v.size() == 5); |
179 | ||
180 | val_type *first = &v.front() + 1; | |
181 | val_type *last = first + 2; | |
d7830142 | 182 | |
15ee1a77 | 183 | cont_type c(last, first); // Expected failure |
d7830142 FD |
184 | } |
185 | ||
186 | // Check that invalid range of debug random iterators is detected | |
187 | template<typename _Tp> | |
188 | void | |
189 | check_construct2() | |
190 | { | |
191 | bool test __attribute__((unused)) = true; | |
192 | ||
193 | typedef _Tp cont_type; | |
194 | typedef typename cont_type::value_type cont_val_type; | |
195 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
196 | typedef std::vector<val_type> vector_type; | |
197 | ||
198 | generate_unique<val_type> gu; | |
199 | ||
200 | vector_type v; | |
201 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 202 | v.push_back(gu.build()); |
d7830142 FD |
203 | VERIFY(v.size() == 5); |
204 | ||
205 | typename vector_type::iterator first = v.begin() + 1; | |
206 | typename vector_type::iterator last = first + 2; | |
d7830142 | 207 | |
15ee1a77 | 208 | cont_type c(last, first); // Expected failure |
d7830142 FD |
209 | } |
210 | ||
211 | // Check that invalid range of debug not random iterators is detected | |
212 | template<typename _Tp> | |
213 | void | |
214 | check_construct3() | |
215 | { | |
216 | bool test __attribute__((unused)) = true; | |
217 | ||
218 | typedef _Tp cont_type; | |
219 | typedef typename cont_type::value_type cont_val_type; | |
220 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
221 | typedef std::list<val_type> list_type; | |
222 | ||
223 | generate_unique<val_type> gu; | |
224 | ||
225 | list_type l; | |
226 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 227 | l.push_back(gu.build()); |
d7830142 FD |
228 | VERIFY(l.size() == 5); |
229 | ||
230 | typename list_type::iterator first = l.begin(); ++first; | |
231 | typename list_type::iterator last = first; ++last; ++last; | |
d7830142 | 232 | |
15ee1a77 | 233 | cont_type c(last, first); // Expected failure |
d7830142 FD |
234 | } |
235 | ||
236 | template <typename _Cont> | |
237 | struct InsertRangeHelper | |
238 | { | |
239 | template <typename _It> | |
240 | static void | |
241 | Insert(_Cont& cont, _It first, _It last) | |
242 | { cont.insert(first, last); } | |
243 | }; | |
244 | ||
245 | template <typename _Cont> | |
246 | struct InsertRangeHelperAux | |
247 | { | |
248 | template <typename _It> | |
249 | static void | |
250 | Insert(_Cont& cont, _It first, _It last) | |
251 | { cont.insert(cont.begin(), first, last); } | |
252 | }; | |
253 | ||
254 | template <typename _Tp1, typename _Tp2> | |
255 | struct InsertRangeHelper<std::vector<_Tp1, _Tp2> > | |
256 | : InsertRangeHelperAux<std::vector<_Tp1, _Tp2> > | |
257 | { }; | |
258 | ||
259 | template <typename _Tp1, typename _Tp2> | |
260 | struct InsertRangeHelper<std::deque<_Tp1, _Tp2> > | |
261 | : InsertRangeHelperAux<std::deque<_Tp1, _Tp2> > | |
262 | { }; | |
263 | ||
264 | template <typename _Tp1, typename _Tp2> | |
265 | struct InsertRangeHelper<std::list<_Tp1, _Tp2> > | |
266 | : InsertRangeHelperAux<std::list<_Tp1, _Tp2> > | |
267 | { }; | |
268 | ||
269 | #ifndef _GLIBCXX_DEBUG | |
270 | template <typename _Tp1, typename _Tp2> | |
271 | struct InsertRangeHelper<__gnu_debug::vector<_Tp1, _Tp2> > | |
272 | : InsertRangeHelperAux<__gnu_debug::vector<_Tp1, _Tp2> > | |
273 | { }; | |
274 | ||
275 | template <typename _Tp1, typename _Tp2> | |
276 | struct InsertRangeHelper<__gnu_debug::deque<_Tp1, _Tp2> > | |
277 | : InsertRangeHelperAux<__gnu_debug::deque<_Tp1, _Tp2> > | |
278 | { }; | |
279 | ||
280 | template <typename _Tp1, typename _Tp2> | |
281 | struct InsertRangeHelper<__gnu_debug::list<_Tp1, _Tp2> > | |
282 | : InsertRangeHelperAux<__gnu_debug::list<_Tp1, _Tp2> > | |
283 | { }; | |
284 | #endif | |
285 | ||
286 | template<typename _Tp> | |
287 | void | |
288 | check_insert1() | |
289 | { | |
290 | bool test __attribute__((unused)) = true; | |
291 | ||
292 | typedef _Tp cont_type; | |
293 | typedef typename cont_type::value_type cont_val_type; | |
294 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
295 | typedef std::vector<val_type> vector_type; | |
296 | ||
297 | generate_unique<val_type> gu; | |
298 | ||
299 | vector_type v; | |
300 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 301 | v.push_back(gu.build()); |
d7830142 FD |
302 | VERIFY(v.size() == 5); |
303 | ||
304 | const val_type* first = &v.front() + 1; | |
305 | const val_type* last = first + 2; | |
306 | ||
307 | cont_type c1; | |
308 | InsertRangeHelper<cont_type>::Insert(c1, first, last); | |
309 | VERIFY(c1.size() == 2); | |
310 | ||
311 | cont_type c2; | |
312 | InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure | |
313 | } | |
314 | ||
315 | template<typename _Tp> | |
316 | void | |
317 | check_insert2() | |
318 | { | |
319 | bool test __attribute__((unused)) = true; | |
320 | ||
321 | typedef _Tp cont_type; | |
322 | typedef typename cont_type::value_type cont_val_type; | |
323 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
324 | typedef std::vector<val_type> vector_type; | |
325 | ||
326 | generate_unique<val_type> gu; | |
327 | ||
328 | vector_type v; | |
329 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 330 | v.push_back(gu.build()); |
d7830142 FD |
331 | VERIFY(v.size() == 5); |
332 | ||
333 | typename vector_type::iterator first = v.begin() + 1; | |
334 | typename vector_type::iterator last = first + 2; | |
335 | ||
336 | cont_type c1; | |
337 | InsertRangeHelper<cont_type>::Insert(c1, first, last); | |
338 | VERIFY(c1.size() == 2); | |
339 | ||
340 | cont_type c2; | |
341 | InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure | |
342 | } | |
343 | ||
344 | template<typename _Tp> | |
345 | void | |
346 | check_insert3() | |
347 | { | |
348 | bool test __attribute__((unused)) = true; | |
349 | ||
350 | typedef _Tp cont_type; | |
351 | typedef typename cont_type::value_type cont_val_type; | |
352 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
353 | typedef std::list<val_type> list_type; | |
354 | ||
355 | generate_unique<val_type> gu; | |
356 | ||
357 | list_type l; | |
358 | for (int i = 0; i != 5; ++i) | |
77e0bf4e | 359 | l.push_back(gu.build()); |
d7830142 FD |
360 | VERIFY(l.size() == 5); |
361 | ||
362 | typename list_type::iterator first = l.begin(); ++first; | |
363 | typename list_type::iterator last = first; ++last; ++last; | |
364 | ||
365 | cont_type c1; | |
366 | InsertRangeHelper<cont_type>::Insert(c1, first, last); | |
367 | VERIFY(c1.size() == 2); | |
368 | ||
369 | cont_type c2; | |
370 | InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure | |
371 | } | |
77e0bf4e | 372 | |
5720787a FD |
373 | template<typename _Tp> |
374 | void | |
375 | check_insert4() | |
376 | { | |
377 | bool test __attribute__((unused)) = true; | |
378 | ||
379 | typedef _Tp cont_type; | |
380 | typedef typename cont_type::value_type cont_val_type; | |
381 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
382 | typedef std::list<val_type> list_type; | |
383 | ||
384 | generate_unique<val_type> gu; | |
385 | ||
386 | list_type l; | |
387 | for (int i = 0; i != 5; ++i) | |
388 | l.push_back(gu.build()); | |
389 | VERIFY(l.size() == 5); | |
390 | ||
391 | typename list_type::iterator first = l.begin(); ++first; | |
392 | typename list_type::iterator last = first; ++last; ++last; | |
393 | ||
394 | cont_type c1; | |
395 | InsertRangeHelper<cont_type>::Insert(c1, l.begin(), l.end()); | |
396 | VERIFY(c1.size() == 5); | |
397 | ||
398 | c1.insert(c1.begin(), c1.begin(), c1.end()); // Expected failure. | |
399 | } | |
400 | ||
77e0bf4e FD |
401 | template<typename _Tp> |
402 | void use_invalid_iterator() | |
403 | { | |
404 | bool test __attribute__((unused)) = true; | |
405 | ||
406 | typedef _Tp cont_type; | |
407 | typedef typename cont_type::value_type cont_val_type; | |
408 | typedef typename CopyableValueType<cont_val_type>::value_type val_type; | |
409 | generate_unique<val_type> gu; | |
410 | ||
411 | cont_type c; | |
412 | for (size_t i = 0; i != 5; ++i) | |
413 | c.insert(gu.build()); | |
414 | ||
415 | typename cont_type::iterator it = c.begin(); | |
416 | cont_val_type val = *it; | |
417 | c.clear(); | |
418 | VERIFY( *it == val ); | |
419 | } | |
d7830142 FD |
420 | } |
421 |