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

source code of boost/libs/container/test/static_vector_test.cpp