]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Container static_vector |
2 | // Unit Test | |
3 | ||
4 | // Copyright (c) 2012-2013 Adam Wulkiewicz, Lodz, Poland. | |
5 | // Copyright (c) 2012-2013 Andrew Hundt. | |
6 | ||
7 | // Use, modification and distribution is subject to the Boost Software License, | |
8 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
9 | // http://www.boost.org/LICENSE_1_0.txt) | |
10 | #include <boost/container/detail/config_begin.hpp> | |
11 | #include <boost/core/lightweight_test.hpp> | |
12 | #include <boost/core/no_exceptions_support.hpp> | |
13 | #include <boost/container/vector.hpp> | |
14 | #include <boost/container/stable_vector.hpp> | |
15 | #include <boost/container/detail/iterator.hpp> | |
16 | #include "../../intrusive/test/iterator_test.hpp" | |
17 | ||
18 | #include <vector> | |
19 | #include <list> | |
20 | ||
21 | #include "static_vector_test.hpp" | |
22 | ||
23 | namespace boost { | |
24 | namespace container { | |
25 | ||
26 | //Explicit instantiation to detect compilation errors | |
27 | template class boost::container::static_vector<int, 10>; | |
28 | ||
29 | }} | |
30 | ||
31 | ||
32 | template <typename T, size_t N> | |
33 | void test_ctor_ndc() | |
34 | { | |
35 | static_vector<T, N> s; | |
36 | BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N); | |
37 | BOOST_TEST_EQ(s.size() , 0u); | |
38 | BOOST_TEST(s.capacity() == N); | |
39 | BOOST_TEST(s.max_size() == N); | |
40 | BOOST_TEST_THROWS( s.at(0u), std::out_of_range ); | |
41 | } | |
42 | ||
43 | template <typename T, size_t N> | |
44 | void test_ctor_nc(size_t n) | |
45 | { | |
46 | static_vector<T, N> s(n); | |
47 | BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N); | |
48 | BOOST_TEST(s.size() == n); | |
49 | BOOST_TEST(s.capacity() == N); | |
50 | BOOST_TEST(s.max_size() == N); | |
51 | BOOST_TEST_THROWS( s.at(n), std::out_of_range ); | |
52 | if ( 1 < n ) | |
53 | { | |
54 | T val10(10); | |
55 | s[0] = val10; | |
56 | BOOST_TEST(T(10) == s[0]); | |
57 | BOOST_TEST(T(10) == s.at(0)); | |
58 | T val20(20); | |
59 | s.at(1) = val20; | |
60 | BOOST_TEST(T(20) == s[1]); | |
61 | BOOST_TEST(T(20) == s.at(1)); | |
62 | } | |
63 | } | |
64 | ||
65 | template <typename T, size_t N> | |
66 | void test_ctor_nd(size_t n, T const& v) | |
67 | { | |
68 | static_vector<T, N> s(n, v); | |
69 | BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N); | |
70 | BOOST_TEST(s.size() == n); | |
71 | BOOST_TEST(s.capacity() == N); | |
72 | BOOST_TEST_THROWS( s.at(n), std::out_of_range ); | |
73 | if ( 1 < n ) | |
74 | { | |
75 | BOOST_TEST(v == s[0]); | |
76 | BOOST_TEST(v == s.at(0)); | |
77 | BOOST_TEST(v == s[1]); | |
78 | BOOST_TEST(v == s.at(1)); | |
79 | s[0] = T(10); | |
80 | BOOST_TEST(T(10) == s[0]); | |
81 | BOOST_TEST(T(10) == s.at(0)); | |
82 | s.at(1) = T(20); | |
83 | BOOST_TEST(T(20) == s[1]); | |
84 | BOOST_TEST(T(20) == s.at(1)); | |
85 | } | |
86 | } | |
87 | ||
88 | void test_support_for_initializer_list() | |
89 | { | |
90 | #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) | |
91 | { | |
92 | static_vector<int, 2> sv = {10, 8}; | |
93 | BOOST_TEST(10 == sv[0]); | |
94 | BOOST_TEST(8 == sv[1]); | |
95 | ||
96 | typedef static_vector<int, 1> sv_cap_1; | |
97 | BOOST_TEST_THROWS(sv_cap_1({1, 1}), std::bad_alloc); | |
98 | } | |
99 | ||
100 | { | |
101 | static_vector<int, 2> sv; | |
102 | sv.assign({1, 2}); | |
103 | BOOST_TEST(1 == sv[0]); | |
104 | BOOST_TEST(2 == sv[1]); | |
105 | ||
106 | BOOST_TEST_THROWS(sv.assign({1, 2, 3}), std::bad_alloc); | |
107 | ||
108 | static_vector<int, 3> greaterThanSv = {1, 2, 3}; | |
109 | BOOST_TEST_THROWS(sv = greaterThanSv, std::bad_alloc); | |
110 | } | |
111 | ||
112 | { | |
113 | static_vector<int, 2> sv; | |
114 | sv.insert(sv.begin(), {99, 95}); | |
115 | BOOST_TEST(99 == sv[0]); | |
116 | BOOST_TEST(95 == sv[1]); | |
117 | ||
118 | BOOST_TEST_THROWS(sv.insert(sv.begin(), {101, 102, 103}), std::bad_alloc); | |
119 | } | |
120 | #endif | |
121 | } | |
122 | ||
123 | template <typename T, size_t N> | |
124 | void test_resize_nc(size_t n) | |
125 | { | |
126 | static_vector<T, N> s; | |
127 | ||
128 | s.resize(n); | |
129 | BOOST_TEST(s.size() == n); | |
130 | BOOST_TEST(s.capacity() == N); | |
131 | BOOST_TEST_THROWS( s.at(n), std::out_of_range ); | |
132 | if ( 1 < n ) | |
133 | { | |
134 | T val10(10); | |
135 | s[0] = val10; | |
136 | BOOST_TEST(T(10) == s[0]); | |
137 | BOOST_TEST(T(10) == s.at(0)); | |
138 | T val20(20); | |
139 | s.at(1) = val20; | |
140 | BOOST_TEST(T(20) == s[1]); | |
141 | BOOST_TEST(T(20) == s.at(1)); | |
142 | } | |
143 | } | |
144 | ||
145 | template <typename T, size_t N> | |
146 | void test_resize_nd(size_t n, T const& v) | |
147 | { | |
148 | static_vector<T, N> s; | |
149 | ||
150 | s.resize(n, v); | |
151 | BOOST_TEST(s.size() == n); | |
152 | BOOST_TEST(s.capacity() == N); | |
153 | BOOST_TEST_THROWS( s.at(n), std::out_of_range ); | |
154 | if ( 1 < n ) | |
155 | { | |
156 | BOOST_TEST(v == s[0]); | |
157 | BOOST_TEST(v == s.at(0)); | |
158 | BOOST_TEST(v == s[1]); | |
159 | BOOST_TEST(v == s.at(1)); | |
160 | s[0] = T(10); | |
161 | BOOST_TEST(T(10) == s[0]); | |
162 | BOOST_TEST(T(10) == s.at(0)); | |
163 | s.at(1) = T(20); | |
164 | BOOST_TEST(T(20) == s[1]); | |
165 | BOOST_TEST(T(20) == s.at(1)); | |
166 | } | |
167 | } | |
168 | ||
169 | template <typename T, size_t N> | |
170 | void test_push_back_nd() | |
171 | { | |
172 | static_vector<T, N> s; | |
173 | ||
174 | BOOST_TEST(s.size() == 0); | |
175 | BOOST_TEST_THROWS( s.at(0), std::out_of_range ); | |
176 | ||
177 | for ( size_t i = 0 ; i < N ; ++i ) | |
178 | { | |
179 | T t(i); | |
180 | s.push_back(t); | |
181 | BOOST_TEST(s.size() == i + 1); | |
182 | BOOST_TEST_THROWS( s.at(i + 1), std::out_of_range ); | |
183 | BOOST_TEST(T(i) == s.at(i)); | |
184 | BOOST_TEST(T(i) == s[i]); | |
185 | BOOST_TEST(T(i) == s.back()); | |
186 | BOOST_TEST(T(0) == s.front()); | |
187 | BOOST_TEST(T(i) == *(s.data() + i)); | |
188 | } | |
189 | } | |
190 | ||
191 | template <typename T, size_t N> | |
192 | void test_pop_back_nd() | |
193 | { | |
194 | static_vector<T, N> s; | |
195 | ||
196 | for ( size_t i = 0 ; i < N ; ++i ) | |
197 | { | |
198 | T t(i); | |
199 | s.push_back(t); | |
200 | } | |
201 | ||
202 | for ( size_t i = N ; i > 1 ; --i ) | |
203 | { | |
204 | s.pop_back(); | |
205 | BOOST_TEST(s.size() == i - 1); | |
206 | BOOST_TEST_THROWS( s.at(i - 1), std::out_of_range ); | |
207 | BOOST_TEST(T(i - 2) == s.at(i - 2)); | |
208 | BOOST_TEST(T(i - 2) == s[i - 2]); | |
209 | BOOST_TEST(T(i - 2) == s.back()); | |
210 | BOOST_TEST(T(0) == s.front()); | |
211 | } | |
212 | } | |
213 | ||
214 | template <typename It1, typename It2> | |
215 | void test_compare_ranges(It1 first1, It1 last1, It2 first2, It2 last2) | |
216 | { | |
217 | BOOST_TEST(boost::container::iterator_distance(first1, last1) == boost::container::iterator_distance(first2, last2)); | |
218 | for ( ; first1 != last1 && first2 != last2 ; ++first1, ++first2 ) | |
219 | BOOST_TEST(*first1 == *first2); | |
220 | } | |
221 | ||
222 | template <typename T, size_t N, typename C> | |
223 | void test_copy_and_assign(C const& c) | |
224 | { | |
225 | { | |
226 | static_vector<T, N> s(c.begin(), c.end()); | |
227 | BOOST_TEST(s.size() == c.size()); | |
228 | test_compare_ranges(s.begin(), s.end(), c.begin(), c.end()); | |
229 | } | |
230 | { | |
231 | static_vector<T, N> s; | |
232 | BOOST_TEST(0 == s.size()); | |
233 | s.assign(c.begin(), c.end()); | |
234 | BOOST_TEST(s.size() == c.size()); | |
235 | test_compare_ranges(s.begin(), s.end(), c.begin(), c.end()); | |
236 | } | |
237 | } | |
238 | ||
239 | template <typename T, size_t N> | |
240 | void test_copy_and_assign_nd(T const& val) | |
241 | { | |
242 | static_vector<T, N> s; | |
243 | std::vector<T> v; | |
244 | std::list<T> l; | |
245 | ||
246 | for ( size_t i = 0 ; i < N ; ++i ) | |
247 | { | |
248 | T t(i); | |
249 | s.push_back(t); | |
250 | v.push_back(t); | |
251 | l.push_back(t); | |
252 | } | |
253 | // copy ctor | |
254 | { | |
255 | static_vector<T, N> s1(s); | |
256 | BOOST_TEST(s.size() == s1.size()); | |
257 | test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end()); | |
258 | } | |
259 | // copy assignment | |
260 | { | |
261 | static_vector<T, N> s1; | |
262 | BOOST_TEST(0 == s1.size()); | |
263 | s1 = s; | |
264 | BOOST_TEST(s.size() == s1.size()); | |
265 | test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end()); | |
266 | } | |
267 | ||
268 | // ctor(Iter, Iter) and assign(Iter, Iter) | |
269 | test_copy_and_assign<T, N>(s); | |
270 | test_copy_and_assign<T, N>(v); | |
271 | test_copy_and_assign<T, N>(l); | |
272 | ||
273 | // assign(N, V) | |
274 | { | |
275 | static_vector<T, N> s1(s); | |
276 | test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end()); | |
277 | std::vector<T> a(N, val); | |
278 | s1.assign(N, val); | |
279 | test_compare_ranges(a.begin(), a.end(), s1.begin(), s1.end()); | |
280 | } | |
281 | ||
282 | stable_vector<T> bsv(s.begin(), s.end()); | |
283 | vector<T> bv(s.begin(), s.end()); | |
284 | test_copy_and_assign<T, N>(bsv); | |
285 | test_copy_and_assign<T, N>(bv); | |
286 | } | |
287 | ||
288 | template <typename T, size_t N> | |
289 | void test_iterators_nd() | |
290 | { | |
291 | static_vector<T, N> s; | |
292 | std::vector<T> v; | |
293 | ||
294 | for ( size_t i = 0 ; i < N ; ++i ) | |
295 | { | |
296 | s.push_back(T(i)); | |
297 | v.push_back(T(i)); | |
298 | } | |
299 | ||
300 | test_compare_ranges(s.begin(), s.end(), v.begin(), v.end()); | |
301 | test_compare_ranges(s.rbegin(), s.rend(), v.rbegin(), v.rend()); | |
302 | ||
303 | s.assign(v.rbegin(), v.rend()); | |
304 | ||
305 | test_compare_ranges(s.begin(), s.end(), v.rbegin(), v.rend()); | |
306 | test_compare_ranges(s.rbegin(), s.rend(), v.begin(), v.end()); | |
307 | } | |
308 | ||
309 | template <typename T, size_t N> | |
310 | void test_erase_nd() | |
311 | { | |
312 | static_vector<T, N> s; | |
313 | typedef typename static_vector<T, N>::iterator It; | |
314 | ||
315 | for ( size_t i = 0 ; i < N ; ++i ) | |
316 | s.push_back(T(i)); | |
317 | ||
318 | // erase(pos) | |
319 | { | |
320 | for ( size_t i = 0 ; i < N ; ++i ) | |
321 | { | |
322 | static_vector<T, N> s1(s); | |
323 | It it = s1.erase(s1.begin() + i); | |
324 | BOOST_TEST(s1.begin() + i == it); | |
325 | BOOST_TEST(s1.size() == N - 1); | |
326 | for ( size_t j = 0 ; j < i ; ++j ) | |
327 | BOOST_TEST(s1[j] == T(j)); | |
328 | for ( size_t j = i+1 ; j < N ; ++j ) | |
329 | BOOST_TEST(s1[j-1] == T(j)); | |
330 | } | |
331 | } | |
332 | // erase(first, last) | |
333 | { | |
334 | size_t n = N/3; | |
335 | for ( size_t i = 0 ; i <= N ; ++i ) | |
336 | { | |
337 | static_vector<T, N> s1(s); | |
338 | size_t removed = i + n < N ? n : N - i; | |
339 | It it = s1.erase(s1.begin() + i, s1.begin() + i + removed); | |
340 | BOOST_TEST(s1.begin() + i == it); | |
341 | BOOST_TEST(s1.size() == N - removed); | |
342 | for ( size_t j = 0 ; j < i ; ++j ) | |
343 | BOOST_TEST(s1[j] == T(j)); | |
344 | for ( size_t j = i+n ; j < N ; ++j ) | |
345 | BOOST_TEST(s1[j-n] == T(j)); | |
346 | } | |
347 | } | |
348 | } | |
349 | ||
350 | template <typename T, size_t N, typename SV, typename C> | |
351 | void test_insert(SV const& s, C const& c) | |
352 | { | |
353 | size_t h = N/2; | |
354 | size_t n = size_t(h/1.5f); | |
355 | ||
356 | for ( size_t i = 0 ; i <= h ; ++i ) | |
357 | { | |
358 | static_vector<T, N> s1(s); | |
359 | ||
360 | typename C::const_iterator it = c.begin(); | |
361 | boost::container::iterator_advance(it, n); | |
362 | typename static_vector<T, N>::iterator | |
363 | it1 = s1.insert(s1.begin() + i, c.begin(), it); | |
364 | ||
365 | BOOST_TEST(s1.begin() + i == it1); | |
366 | BOOST_TEST(s1.size() == h+n); | |
367 | for ( size_t j = 0 ; j < i ; ++j ) | |
368 | BOOST_TEST(s1[j] == T(j)); | |
369 | for ( size_t j = 0 ; j < n ; ++j ) | |
370 | BOOST_TEST(s1[j+i] == T(100 + j)); | |
371 | for ( size_t j = 0 ; j < h-i ; ++j ) | |
372 | BOOST_TEST(s1[j+i+n] == T(j+i)); | |
373 | } | |
374 | } | |
375 | ||
376 | template <typename T, size_t N> | |
377 | void test_insert_nd(T const& val) | |
378 | { | |
379 | size_t h = N/2; | |
380 | ||
381 | static_vector<T, N> s, ss; | |
382 | std::vector<T> v; | |
383 | std::list<T> l; | |
384 | ||
385 | typedef typename static_vector<T, N>::iterator It; | |
386 | ||
387 | for ( size_t i = 0 ; i < h ; ++i ) | |
388 | { | |
389 | s.push_back(T(i)); | |
390 | ss.push_back(T(100 + i)); | |
391 | v.push_back(T(100 + i)); | |
392 | l.push_back(T(100 + i)); | |
393 | } | |
394 | ||
395 | // insert(pos, val) | |
396 | { | |
397 | for ( size_t i = 0 ; i <= h ; ++i ) | |
398 | { | |
399 | static_vector<T, N> s1(s); | |
400 | It it = s1.insert(s1.begin() + i, val); | |
401 | BOOST_TEST(s1.begin() + i == it); | |
402 | BOOST_TEST(s1.size() == h+1); | |
403 | for ( size_t j = 0 ; j < i ; ++j ) | |
404 | BOOST_TEST(s1[j] == T(j)); | |
405 | BOOST_TEST(s1[i] == val); | |
406 | for ( size_t j = 0 ; j < h-i ; ++j ) | |
407 | BOOST_TEST(s1[j+i+1] == T(j+i)); | |
408 | } | |
409 | } | |
410 | // insert(pos, n, val) | |
411 | { | |
412 | size_t n = size_t(h/1.5f); | |
413 | for ( size_t i = 0 ; i <= h ; ++i ) | |
414 | { | |
415 | static_vector<T, N> s1(s); | |
416 | It it = s1.insert(s1.begin() + i, n, val); | |
417 | BOOST_TEST(s1.begin() + i == it); | |
418 | BOOST_TEST(s1.size() == h+n); | |
419 | for ( size_t j = 0 ; j < i ; ++j ) | |
420 | BOOST_TEST(s1[j] == T(j)); | |
421 | for ( size_t j = 0 ; j < n ; ++j ) | |
422 | BOOST_TEST(s1[j+i] == val); | |
423 | for ( size_t j = 0 ; j < h-i ; ++j ) | |
424 | BOOST_TEST(s1[j+i+n] == T(j+i)); | |
425 | } | |
426 | } | |
427 | // insert(pos, first, last) | |
428 | test_insert<T, N>(s, ss); | |
429 | test_insert<T, N>(s, v); | |
430 | test_insert<T, N>(s, l); | |
431 | ||
432 | stable_vector<T> bsv(ss.begin(), ss.end()); | |
433 | vector<T> bv(ss.begin(), ss.end()); | |
434 | test_insert<T, N>(s, bv); | |
435 | test_insert<T, N>(s, bsv); | |
436 | } | |
437 | ||
438 | template <typename T> | |
439 | void test_capacity_0_nd() | |
440 | { | |
441 | static_vector<T, 10> v(5u, T(0)); | |
442 | ||
443 | static_vector<T, 0 > s; | |
444 | BOOST_TEST(s.size() == 0); | |
445 | BOOST_TEST(s.capacity() == 0); | |
446 | BOOST_TEST_THROWS(s.at(0), std::out_of_range); | |
447 | BOOST_TEST_THROWS(s.resize(5u, T(0)), std::bad_alloc); | |
448 | BOOST_TEST_THROWS(s.push_back(T(0)), std::bad_alloc); | |
449 | BOOST_TEST_THROWS(s.insert(s.end(), T(0)), std::bad_alloc); | |
450 | BOOST_TEST_THROWS(s.insert(s.end(), 5u, T(0)), std::bad_alloc); | |
451 | BOOST_TEST_THROWS(s.insert(s.end(), v.begin(), v.end()), std::bad_alloc); | |
452 | BOOST_TEST_THROWS(s.assign(v.begin(), v.end()), std::bad_alloc); | |
453 | BOOST_TEST_THROWS(s.assign(5u, T(0)), std::bad_alloc); | |
454 | BOOST_TEST_THROWS(s.assign(5u, T(0)), std::bad_alloc); | |
455 | typedef static_vector<T, 0> static_vector_0_t; | |
456 | BOOST_TEST_THROWS(static_vector_0_t s2(v.begin(), v.end()), std::bad_alloc); | |
457 | BOOST_TEST_THROWS(static_vector_0_t s1(5u, T(0)), std::bad_alloc); | |
458 | } | |
459 | ||
460 | template <typename T, size_t N> | |
461 | void test_exceptions_nd() | |
462 | { | |
463 | static_vector<T, N> v(N, T(0)); | |
464 | static_vector<T, N/2> s(N/2, T(0)); | |
465 | ||
466 | BOOST_TEST_THROWS(s.resize(N, T(0)), std::bad_alloc); | |
467 | BOOST_TEST_THROWS(s.push_back(T(0)), std::bad_alloc); | |
468 | BOOST_TEST_THROWS(s.insert(s.end(), T(0)), std::bad_alloc); | |
469 | BOOST_TEST_THROWS(s.insert(s.end(), N, T(0)), std::bad_alloc); | |
470 | BOOST_TEST_THROWS(s.insert(s.end(), v.begin(), v.end()), std::bad_alloc); | |
471 | BOOST_TEST_THROWS(s.assign(v.begin(), v.end()), std::bad_alloc); | |
472 | BOOST_TEST_THROWS(s.assign(N, T(0)), std::bad_alloc); | |
473 | typedef static_vector<T, N/2> static_vector_n_half_t; | |
474 | BOOST_TEST_THROWS(static_vector_n_half_t s2(v.begin(), v.end()), std::bad_alloc); | |
475 | BOOST_TEST_THROWS(static_vector_n_half_t s1(N, T(0)), std::bad_alloc); | |
476 | } | |
477 | ||
478 | template <typename T, size_t N> | |
479 | void test_swap_and_move_nd() | |
480 | { | |
481 | { | |
482 | static_vector<T, N> v1, v2, v3, v4; | |
483 | static_vector<T, N> s1, s2; | |
484 | static_vector<T, N> s4; | |
485 | ||
486 | for (size_t i = 0 ; i < N ; ++i ) | |
487 | { | |
488 | v1.push_back(T(i)); | |
489 | v2.push_back(T(i)); | |
490 | v3.push_back(T(i)); | |
491 | v4.push_back(T(i)); | |
492 | } | |
493 | for (size_t i = 0 ; i < N/2 ; ++i ) | |
494 | { | |
495 | s1.push_back(T(100 + i)); | |
496 | s2.push_back(T(100 + i)); | |
497 | s4.push_back(T(100 + i)); | |
498 | } | |
499 | ||
500 | s1.swap(v1); | |
501 | s2 = boost::move(v2); | |
502 | static_vector<T, N> s3(boost::move(v3)); | |
503 | s4.swap(v4); | |
504 | ||
505 | BOOST_TEST(v1.size() == N/2); | |
506 | BOOST_TEST(s1.size() == N); | |
507 | //iG moving does not imply emptying source | |
508 | //BOOST_TEST(v2.size() == 0); | |
509 | BOOST_TEST(s2.size() == N); | |
510 | //iG moving does not imply emptying source | |
511 | //BOOST_TEST(v3.size() == 0); | |
512 | BOOST_TEST(s3.size() == N); | |
513 | BOOST_TEST(v4.size() == N/2); | |
514 | BOOST_TEST(s4.size() == N); | |
515 | for (size_t i = 0 ; i < N/2 ; ++i ) | |
516 | { | |
517 | BOOST_TEST(v1[i] == T(100 + i)); | |
518 | BOOST_TEST(v4[i] == T(100 + i)); | |
519 | } | |
520 | for (size_t i = 0 ; i < N ; ++i ) | |
521 | { | |
522 | BOOST_TEST(s1[i] == T(i)); | |
523 | BOOST_TEST(s2[i] == T(i)); | |
524 | BOOST_TEST(s3[i] == T(i)); | |
525 | BOOST_TEST(s4[i] == T(i)); | |
526 | } | |
527 | } | |
528 | { | |
529 | static_vector<T, N> v1, v2, v3; | |
530 | static_vector<T, N/2> s1, s2, s3; | |
531 | ||
532 | for (size_t i = 0 ; i < N/2 ; ++i ) | |
533 | { | |
534 | v1.push_back(T(i)); | |
535 | v2.push_back(T(i)); | |
536 | v3.push_back(T(i)); | |
537 | } | |
538 | for (size_t i = 0 ; i < N/3 ; ++i ) | |
539 | { | |
540 | s1.push_back(T(100 + i)); | |
541 | s2.push_back(T(100 + i)); | |
542 | } | |
543 | ||
544 | s1.swap(v1); | |
545 | s3 = v2; | |
546 | s2 = boost::move(v2); | |
547 | static_vector<T, N/2> s4(boost::move(v3)); | |
548 | ||
549 | BOOST_TEST(v1.size() == N/3); | |
550 | BOOST_TEST(s1.size() == N/2); | |
551 | //iG moving does not imply emptying source | |
552 | //BOOST_TEST(v2.size() == 0); | |
553 | BOOST_TEST(s2.size() == N/2); | |
554 | BOOST_TEST(s3.size() == N/2); | |
555 | //iG moving does not imply emptying source | |
556 | //BOOST_TEST(v3.size() == 0); | |
557 | BOOST_TEST(s4.size() == N/2); | |
558 | for (size_t i = 0 ; i < N/3 ; ++i ) | |
559 | BOOST_TEST(v1[i] == T(100 + i)); | |
560 | for (size_t i = 0 ; i < N/2 ; ++i ) | |
561 | { | |
562 | BOOST_TEST(s1[i] == T(i)); | |
563 | BOOST_TEST(s2[i] == T(i)); | |
564 | BOOST_TEST(s3[i] == T(i)); | |
565 | BOOST_TEST(s4[i] == T(i)); | |
566 | } | |
567 | } | |
568 | { | |
569 | typedef static_vector<T, N/2> small_vector_t; | |
570 | static_vector<T, N> v(N, T(0)); | |
571 | small_vector_t s(N/2, T(1)); | |
572 | BOOST_TEST_THROWS(s.swap(v), std::bad_alloc); | |
573 | v.resize(N, T(0)); | |
574 | BOOST_TEST_THROWS(s = boost::move(v), std::bad_alloc); | |
575 | BOOST_TEST_THROWS(s = v, std::bad_alloc); | |
576 | v.resize(N, T(0)); | |
577 | BOOST_TEST_THROWS(small_vector_t s2(boost::move(v)), std::bad_alloc); | |
578 | } | |
579 | } | |
580 | ||
581 | template <typename T, size_t N> | |
582 | void test_emplace_0p() | |
583 | { | |
584 | //emplace_back() | |
585 | { | |
586 | static_vector<T, N> v; | |
587 | ||
588 | for (int i = 0 ; i < int(N) ; ++i ) | |
589 | v.emplace_back(); | |
590 | BOOST_TEST(v.size() == N); | |
591 | BOOST_TEST_THROWS(v.emplace_back(), std::bad_alloc); | |
592 | } | |
593 | } | |
594 | ||
595 | template <typename T, size_t N> | |
596 | void test_emplace_2p() | |
597 | { | |
598 | //emplace_back(pos, int, int) | |
599 | { | |
600 | static_vector<T, N> v; | |
601 | ||
602 | for (int i = 0 ; i < int(N) ; ++i ) | |
603 | v.emplace_back(i, 100 + i); | |
604 | BOOST_TEST(v.size() == N); | |
605 | BOOST_TEST_THROWS(v.emplace_back(N, 100 + N), std::bad_alloc); | |
606 | BOOST_TEST(v.size() == N); | |
607 | for (int i = 0 ; i < int(N) ; ++i ) | |
608 | BOOST_TEST(v[i] == T(i, 100 + i)); | |
609 | } | |
610 | ||
611 | // emplace(pos, int, int) | |
612 | { | |
613 | typedef typename static_vector<T, N>::iterator It; | |
614 | ||
615 | int h = N / 2; | |
616 | ||
617 | static_vector<T, N> v; | |
618 | for ( int i = 0 ; i < h ; ++i ) | |
619 | v.emplace_back(i, 100 + i); | |
620 | ||
621 | for ( int i = 0 ; i <= h ; ++i ) | |
622 | { | |
623 | static_vector<T, N> vv(v); | |
624 | It it = vv.emplace(vv.begin() + i, i+100, i+200); | |
625 | BOOST_TEST(vv.begin() + i == it); | |
626 | BOOST_TEST(vv.size() == size_t(h+1)); | |
627 | for ( int j = 0 ; j < i ; ++j ) | |
628 | BOOST_TEST(vv[j] == T(j, j+100)); | |
629 | BOOST_TEST(vv[i] == T(i+100, i+200)); | |
630 | for ( int j = 0 ; j < h-i ; ++j ) | |
631 | BOOST_TEST(vv[j+i+1] == T(j+i, j+i+100)); | |
632 | } | |
633 | } | |
634 | } | |
635 | ||
636 | template <typename T, size_t N> | |
637 | void test_sv_elem(T const& t) | |
638 | { | |
639 | typedef static_vector<T, N> V; | |
640 | ||
641 | static_vector<V, N> v; | |
642 | ||
643 | v.push_back(V(N/2, t)); | |
644 | V vvv(N/2, t); | |
645 | v.push_back(boost::move(vvv)); | |
646 | v.insert(v.begin(), V(N/2, t)); | |
647 | v.insert(v.end(), V(N/2, t)); | |
648 | v.emplace_back(N/2, t); | |
649 | } | |
650 | ||
651 | bool default_init_test()//Test for default initialization | |
652 | { | |
653 | typedef static_vector<int, 100> di_vector_t; | |
654 | ||
655 | const std::size_t Capacity = 100; | |
656 | ||
657 | { | |
658 | di_vector_t v; | |
659 | int *p = v.data(); | |
660 | ||
661 | for(std::size_t i = 0; i != Capacity; ++i, ++p){ | |
662 | *p = static_cast<int>(i); | |
663 | } | |
664 | ||
665 | //Destroy the vector, p stilll pointing to the storage | |
666 | v.~di_vector_t(); | |
667 | ||
668 | di_vector_t &rv = *::new(&v)di_vector_t(Capacity, default_init); | |
669 | di_vector_t::iterator it = rv.begin(); | |
670 | ||
671 | for(std::size_t i = 0; i != Capacity; ++i, ++it){ | |
672 | if(*it != static_cast<int>(i)) | |
673 | return false; | |
674 | } | |
675 | ||
676 | v.~di_vector_t(); | |
677 | } | |
678 | { | |
679 | di_vector_t v; | |
680 | ||
681 | int *p = v.data(); | |
682 | for(std::size_t i = 0; i != Capacity; ++i, ++p){ | |
683 | *p = static_cast<int>(i+100); | |
684 | } | |
685 | ||
686 | v.resize(Capacity, default_init); | |
687 | ||
688 | di_vector_t::iterator it = v.begin(); | |
689 | for(std::size_t i = 0; i != Capacity; ++i, ++it){ | |
690 | if(*it != static_cast<int>(i+100)) | |
691 | return false; | |
692 | } | |
693 | } | |
694 | ||
695 | return true; | |
696 | } | |
697 | ||
698 | ||
699 | int main(int, char* []) | |
700 | { | |
701 | using boost::container::test::movable_and_copyable_int; | |
702 | using boost::container::test::produce_movable_and_copyable_int; | |
703 | BOOST_TEST(counting_value::count() == 0); | |
704 | ||
705 | test_ctor_ndc<int, 10>(); | |
706 | test_ctor_ndc<value_ndc, 10>(); | |
707 | test_ctor_ndc<counting_value, 10>(); | |
708 | BOOST_TEST(counting_value::count() == 0); | |
709 | test_ctor_ndc<shptr_value, 10>(); | |
710 | test_ctor_ndc<movable_and_copyable_int, 10>(); | |
711 | ||
712 | test_ctor_nc<int, 10>(5); | |
713 | test_ctor_nc<value_nc, 10>(5); | |
714 | test_ctor_nc<counting_value, 10>(5); | |
715 | BOOST_TEST(counting_value::count() == 0); | |
716 | test_ctor_nc<shptr_value, 10>(5); | |
717 | test_ctor_nc<movable_and_copyable_int, 10>(5); | |
718 | ||
719 | test_ctor_nd<int, 10>(5, 1); | |
720 | test_ctor_nd<value_nd, 10>(5, value_nd(1)); | |
721 | test_ctor_nd<counting_value, 10>(5, counting_value(1)); | |
722 | BOOST_TEST(counting_value::count() == 0); | |
723 | test_ctor_nd<shptr_value, 10>(5, shptr_value(1)); | |
724 | test_ctor_nd<movable_and_copyable_int, 10>(5, produce_movable_and_copyable_int()); | |
725 | ||
726 | test_resize_nc<int, 10>(5); | |
727 | test_resize_nc<value_nc, 10>(5); | |
728 | test_resize_nc<counting_value, 10>(5); | |
729 | BOOST_TEST(counting_value::count() == 0); | |
730 | test_resize_nc<shptr_value, 10>(5); | |
731 | test_resize_nc<movable_and_copyable_int, 10>(5); | |
732 | ||
733 | test_resize_nd<int, 10>(5, 1); | |
734 | test_resize_nd<value_nd, 10>(5, value_nd(1)); | |
735 | test_resize_nd<counting_value, 10>(5, counting_value(1)); | |
736 | BOOST_TEST(counting_value::count() == 0); | |
737 | test_resize_nd<shptr_value, 10>(5, shptr_value(1)); | |
738 | test_resize_nd<movable_and_copyable_int, 10>(5, produce_movable_and_copyable_int()); | |
739 | ||
740 | test_push_back_nd<int, 10>(); | |
741 | test_push_back_nd<value_nd, 10>(); | |
742 | test_push_back_nd<counting_value, 10>(); | |
743 | BOOST_TEST(counting_value::count() == 0); | |
744 | test_push_back_nd<shptr_value, 10>(); | |
745 | test_push_back_nd<movable_and_copyable_int, 10>(); | |
746 | ||
747 | test_pop_back_nd<int, 10>(); | |
748 | test_pop_back_nd<value_nd, 10>(); | |
749 | test_pop_back_nd<counting_value, 10>(); | |
750 | BOOST_TEST(counting_value::count() == 0); | |
751 | test_pop_back_nd<shptr_value, 10>(); | |
752 | test_pop_back_nd<movable_and_copyable_int, 10>(); | |
753 | ||
754 | test_copy_and_assign_nd<int, 10>(1); | |
755 | test_copy_and_assign_nd<value_nd, 10>(value_nd(1)); | |
756 | test_copy_and_assign_nd<counting_value, 10>(counting_value(1)); | |
757 | BOOST_TEST(counting_value::count() == 0); | |
758 | test_copy_and_assign_nd<shptr_value, 10>(shptr_value(1)); | |
759 | test_copy_and_assign_nd<movable_and_copyable_int, 10>(produce_movable_and_copyable_int()); | |
760 | ||
761 | test_iterators_nd<int, 10>(); | |
762 | test_iterators_nd<value_nd, 10>(); | |
763 | test_iterators_nd<counting_value, 10>(); | |
764 | BOOST_TEST(counting_value::count() == 0); | |
765 | test_iterators_nd<shptr_value, 10>(); | |
766 | test_iterators_nd<movable_and_copyable_int, 10>(); | |
767 | ||
768 | test_erase_nd<int, 10>(); | |
769 | test_erase_nd<value_nd, 10>(); | |
770 | test_erase_nd<counting_value, 10>(); | |
771 | BOOST_TEST(counting_value::count() == 0); | |
772 | test_erase_nd<shptr_value, 10>(); | |
773 | test_erase_nd<movable_and_copyable_int, 10>(); | |
774 | ||
775 | test_insert_nd<int, 10>(50); | |
776 | test_insert_nd<value_nd, 10>(value_nd(50)); | |
777 | test_insert_nd<counting_value, 10>(counting_value(50)); | |
778 | BOOST_TEST(counting_value::count() == 0); | |
779 | test_insert_nd<shptr_value, 10>(shptr_value(50)); | |
780 | test_insert_nd<movable_and_copyable_int, 10>(produce_movable_and_copyable_int()); | |
781 | ||
782 | test_capacity_0_nd<int>(); | |
783 | test_capacity_0_nd<value_nd>(); | |
784 | test_capacity_0_nd<counting_value>(); | |
785 | BOOST_TEST(counting_value::count() == 0); | |
786 | test_capacity_0_nd<shptr_value>(); | |
787 | test_capacity_0_nd<movable_and_copyable_int>(); | |
788 | ||
789 | test_exceptions_nd<int, 10>(); | |
790 | test_exceptions_nd<value_nd, 10>(); | |
791 | test_exceptions_nd<counting_value, 10>(); | |
792 | BOOST_TEST(counting_value::count() == 0); | |
793 | test_exceptions_nd<shptr_value, 10>(); | |
794 | test_exceptions_nd<movable_and_copyable_int, 10>(); | |
795 | ||
796 | test_swap_and_move_nd<int, 10>(); | |
797 | test_swap_and_move_nd<value_nd, 10>(); | |
798 | test_swap_and_move_nd<counting_value, 10>(); | |
799 | BOOST_TEST(counting_value::count() == 0); | |
800 | test_swap_and_move_nd<shptr_value, 10>(); | |
801 | test_swap_and_move_nd<movable_and_copyable_int, 10>(); | |
802 | ||
803 | test_emplace_0p<counting_value, 10>(); | |
804 | BOOST_TEST(counting_value::count() == 0); | |
805 | ||
806 | test_emplace_2p<counting_value, 10>(); | |
807 | BOOST_TEST(counting_value::count() == 0); | |
808 | ||
809 | test_sv_elem<int, 10>(50); | |
810 | test_sv_elem<value_nd, 10>(value_nd(50)); | |
811 | test_sv_elem<counting_value, 10>(counting_value(50)); | |
812 | BOOST_TEST(counting_value::count() == 0); | |
813 | test_sv_elem<shptr_value, 10>(shptr_value(50)); | |
814 | test_sv_elem<movable_and_copyable_int, 10>(movable_and_copyable_int(50)); | |
815 | ||
816 | BOOST_TEST(default_init_test() == true); | |
817 | ||
818 | test_support_for_initializer_list(); | |
819 | ||
820 | //////////////////////////////////// | |
821 | // Iterator testing | |
822 | //////////////////////////////////// | |
823 | { | |
824 | typedef boost::container::static_vector<int, 3> cont_int; | |
825 | cont_int a; a.push_back(0); a.push_back(1); a.push_back(2); | |
826 | boost::intrusive::test::test_iterator_random< cont_int >(a); | |
827 | } | |
828 | ||
829 | return boost::report_errors(); | |
830 | } | |
831 | ||
832 | #include <boost/container/detail/config_end.hpp> |