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