1 // Copyright (C) 2019 T. Zachary Laine
2 //
3 // Distributed under the Boost Software License, Version 1.0. (See
4 // accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
6 #include "../example/static_vector.hpp"
7
8 #include "ill_formed.hpp"
9
10 #include <boost/core/lightweight_test.hpp>
11
12 #include <array>
13
14
15 struct noncopyable_int
16 {
noncopyable_intnoncopyable_int17 noncopyable_int() : value_(0) {}
18
19 noncopyable_int(noncopyable_int const &) = delete;
noncopyable_intnoncopyable_int20 noncopyable_int(noncopyable_int && other) : value_(other.value_) {}
21 noncopyable_int & operator=(noncopyable_int const &) = delete;
operator =noncopyable_int22 noncopyable_int & operator=(noncopyable_int && rhs)
23 {
24 value_ = rhs.value_;
25 return *this;
26 }
27
noncopyable_intnoncopyable_int28 noncopyable_int(int i) : value_(i) {}
operator =noncopyable_int29 noncopyable_int & operator=(int i)
30 {
31 value_ = i;
32 return *this;
33 }
34
operator intnoncopyable_int35 operator int() const { return value_; }
36
37 int value_;
38 };
39
swap(noncopyable_int & x,noncopyable_int & y)40 void swap(noncopyable_int & x, noncopyable_int & y)
41 {
42 std::swap(x.value_, y.value_);
43 }
44
45 #define USE_STD_VECTOR 0
46
47 #if USE_STD_VECTOR
48 using vec_type = std::vector<noncopyable_int>;
49 #else
50 using vec_type = static_vector<noncopyable_int, 10>;
51 #endif
52
53
test_default_ctor()54 void test_default_ctor()
55 {
56 vec_type v;
57 BOOST_TEST(v.empty());
58 BOOST_TEST(v.size() == 0u);
59
60 #if !USE_STD_VECTOR
61 BOOST_TEST(v.max_size() == 10u);
62 BOOST_TEST(v.capacity() == 10u);
63 #endif
64
65 BOOST_TEST(v == v);
66 BOOST_TEST(v <= v);
67 BOOST_TEST(v >= v);
68
69 BOOST_TEST_THROWS(v.at(0), std::out_of_range);
70
71 vec_type const & cv = v;
72 BOOST_TEST(cv.empty());
73 BOOST_TEST(cv.size() == 0u);
74
75 #if !USE_STD_VECTOR
76 BOOST_TEST(cv.max_size() == 10u);
77 BOOST_TEST(cv.capacity() == 10u);
78 #endif
79
80 BOOST_TEST(cv == cv);
81 BOOST_TEST(cv <= cv);
82 BOOST_TEST(cv >= cv);
83
84 BOOST_TEST_THROWS(cv.at(0), std::out_of_range);
85 }
86
87
test_other_ctors_assign_ctor()88 void test_other_ctors_assign_ctor()
89 {
90 {
91 vec_type v(3);
92 BOOST_TEST(!v.empty());
93 BOOST_TEST(v.size() == 3u);
94 }
95
96 #if 0 // initializer_list construction is not supported for move-only value_type.
97 vec_type v2(std::initializer_list<noncopyable_int>{0, 0, 0});
98 BOOST_TEST(v == v2);
99
100 {
101 std::initializer_list<noncopyable_int> il{3, 2, 1};
102 vec_type v(il);
103 BOOST_TEST(!v.empty());
104 BOOST_TEST(v.size() == 3u);
105
106 static_assert(std::is_same<decltype(v = il), vec_type &>::value, "");
107
108 vec_type v2;
109 v2 = il;
110 BOOST_TEST(v == v2);
111 }
112
113 {
114 std::initializer_list<noncopyable_int> il{3, 2, 1};
115 vec_type v;
116 v.assign(il);
117 BOOST_TEST(!v.empty());
118 BOOST_TEST(v.size() == 3u);
119
120 static_assert(std::is_same<decltype(v.assign(il)), void>::value, "");
121
122 vec_type v2;
123 v2 = il;
124 BOOST_TEST(v == v2);
125 }
126 #endif
127
128 #if 0 // Code that boils down to fill-insert is not supported for move-only value_type.
129 {
130 vec_type v(3, 4);
131 BOOST_TEST(!v.empty());
132 BOOST_TEST(v.size() == 3u);
133
134 vec_type v2 = {4, 4, 4};
135 BOOST_TEST(v == v2);
136 }
137
138 {
139 vec_type v;
140 v.assign(3, 4);
141 BOOST_TEST(!v.empty());
142 BOOST_TEST(v.size() == 3u);
143
144 static_assert(std::is_same<decltype(v.assign(3, 4)), void>::value, "");
145
146 vec_type v2 = {4, 4, 4};
147 BOOST_TEST(v == v2);
148 }
149 #endif
150
151 {
152 std::array<int, 3> a = {{1, 2, 3}};
153
154 vec_type v(a.begin(), a.end());
155 BOOST_TEST(!v.empty());
156 BOOST_TEST(v.size() == 3u);
157
158 vec_type v2;
159 v2.push_back(1);
160 v2.push_back(2);
161 v2.push_back(3);
162 BOOST_TEST(v == v2);
163 }
164
165 {
166 std::array<int, 3> a = {{1, 2, 3}};
167
168 vec_type v;
169 v.assign(a.begin(), a.end());
170 BOOST_TEST(!v.empty());
171 BOOST_TEST(v.size() == 3u);
172
173 static_assert(
174 std::is_same<decltype(v.assign(a.begin(), a.end())), void>::value,
175 "");
176
177 vec_type v2;
178 v2.push_back(1);
179 v2.push_back(2);
180 v2.push_back(3);
181 BOOST_TEST(v == v2);
182 }
183 }
184
185
test_resize()186 void test_resize()
187 {
188 {
189 vec_type v;
190
191 static_assert(std::is_same<decltype(v.resize(1)), void>::value, "");
192
193 v.resize(3);
194 BOOST_TEST(v == vec_type(3));
195
196 v.resize(6);
197 BOOST_TEST(v == vec_type(6));
198 }
199
200 {
201 vec_type v(6);
202
203 v.resize(3);
204 BOOST_TEST(v == vec_type(3));
205
206 v.resize(0);
207 BOOST_TEST(v == vec_type{});
208 }
209 }
210
211
test_assignment_copy_move_equality()212 void test_assignment_copy_move_equality()
213 {
214 {
215 vec_type v2;
216 v2.push_back(4);
217 v2.push_back(4);
218 v2.push_back(4);
219
220 vec_type v(std::move(v2));
221 BOOST_TEST(v[0] == 4);
222 BOOST_TEST(v[1] == 4);
223 BOOST_TEST(v[2] == 4);
224 BOOST_TEST(v2.empty());
225 }
226
227 {
228 vec_type v;
229 vec_type v2;
230 v2.push_back(4);
231 v2.push_back(4);
232 v2.push_back(4);
233
234 v = std::move(v2);
235 BOOST_TEST(v[0] == 4);
236 BOOST_TEST(v[1] == 4);
237 BOOST_TEST(v[2] == 4);
238 BOOST_TEST(v2.empty());
239 }
240 }
241
242
test_comparisons()243 void test_comparisons()
244 {
245 vec_type sm;
246 sm.push_back(1);
247 sm.push_back(2);
248 sm.push_back(3);
249 vec_type md;
250 md.push_back(1);
251 md.push_back(2);
252 md.push_back(3);
253 md.push_back(4);
254 vec_type lg;
255 lg.push_back(1);
256 lg.push_back(2);
257 lg.push_back(3);
258 lg.push_back(4);
259 lg.push_back(5);
260
261 BOOST_TEST(sm == sm);
262 BOOST_TEST(!(sm == md));
263 BOOST_TEST(!(sm == lg));
264
265 BOOST_TEST(!(sm != sm));
266 BOOST_TEST(sm != md);
267 BOOST_TEST(sm != lg);
268
269 BOOST_TEST(!(sm < sm));
270 BOOST_TEST(sm < md);
271 BOOST_TEST(sm < lg);
272
273 BOOST_TEST(sm <= sm);
274 BOOST_TEST(sm <= md);
275 BOOST_TEST(sm <= lg);
276
277 BOOST_TEST(!(sm > sm));
278 BOOST_TEST(!(sm > md));
279 BOOST_TEST(!(sm > lg));
280
281 BOOST_TEST(sm >= sm);
282 BOOST_TEST(!(sm >= md));
283 BOOST_TEST(!(sm >= lg));
284
285
286 BOOST_TEST(!(md == sm));
287 BOOST_TEST(md == md);
288 BOOST_TEST(!(md == lg));
289
290 BOOST_TEST(!(md < sm));
291 BOOST_TEST(!(md < md));
292 BOOST_TEST(md < lg);
293
294 BOOST_TEST(!(md <= sm));
295 BOOST_TEST(md <= md);
296 BOOST_TEST(md <= lg);
297
298 BOOST_TEST(md > sm);
299 BOOST_TEST(!(md > md));
300 BOOST_TEST(!(md > lg));
301
302 BOOST_TEST(md >= sm);
303 BOOST_TEST(md >= md);
304 BOOST_TEST(!(md >= lg));
305
306
307 BOOST_TEST(!(lg == sm));
308 BOOST_TEST(!(lg == md));
309 BOOST_TEST(lg == lg);
310
311 BOOST_TEST(!(lg < sm));
312 BOOST_TEST(!(lg < md));
313 BOOST_TEST(!(lg < lg));
314
315 BOOST_TEST(!(lg <= sm));
316 BOOST_TEST(!(lg <= md));
317 BOOST_TEST(lg <= lg);
318
319 BOOST_TEST(lg > sm);
320 BOOST_TEST(lg > md);
321 BOOST_TEST(!(lg > lg));
322
323 BOOST_TEST(lg >= sm);
324 BOOST_TEST(lg >= md);
325 BOOST_TEST(lg >= lg);
326 }
327
328
test_swap()329 void test_swap()
330 {
331 {
332 vec_type v1;
333 v1.push_back(4);
334 v1.push_back(4);
335 v1.push_back(4);
336 vec_type v2;
337 v2.push_back(3);
338 v2.push_back(3);
339 v2.push_back(3);
340 v2.push_back(3);
341
342 static_assert(std::is_same<decltype(v1.swap(v2)), void>::value, "");
343 static_assert(std::is_same<decltype(swap(v1, v2)), void>::value, "");
344
345 v1.swap(v2);
346
347 BOOST_TEST(v1.size() == 4u);
348 BOOST_TEST(v2.size() == 3u);
349
350 BOOST_TEST(v1[0] == 3);
351 BOOST_TEST(v2[0] == 4);
352 }
353
354 {
355 vec_type v1;
356 v1.push_back(4);
357 v1.push_back(4);
358 v1.push_back(4);
359 vec_type v2;
360 v2.push_back(3);
361 v2.push_back(3);
362 v2.push_back(3);
363 v2.push_back(3);
364
365 swap(v1, v2);
366
367 BOOST_TEST(v1.size() == 4u);
368 BOOST_TEST(v2.size() == 3u);
369
370 BOOST_TEST(v1[0] == 3);
371 BOOST_TEST(v2[0] == 4);
372 }
373 }
374
375 template<typename Iter>
376 using writable_iter_t = decltype(
377 *std::declval<Iter>() =
378 std::declval<typename std::iterator_traits<Iter>::value_type>());
379
380 static_assert(
381 ill_formed<
382 writable_iter_t,
383 decltype(std::declval<vec_type const &>().begin())>::value,
384 "");
385 static_assert(
386 ill_formed<
387 writable_iter_t,
388 decltype(std::declval<vec_type const &>().end())>::value,
389 "");
390 static_assert(
391 ill_formed<writable_iter_t, decltype(std::declval<vec_type &>().cbegin())>::
392 value,
393 "");
394 static_assert(
395 ill_formed<writable_iter_t, decltype(std::declval<vec_type &>().cend())>::
396 value,
397 "");
398
399 static_assert(
400 ill_formed<
401 writable_iter_t,
402 decltype(std::declval<vec_type const &>().rbegin())>::value,
403 "");
404 static_assert(
405 ill_formed<
406 writable_iter_t,
407 decltype(std::declval<vec_type const &>().rend())>::value,
408 "");
409 static_assert(
410 ill_formed<
411 writable_iter_t,
412 decltype(std::declval<vec_type &>().crbegin())>::value,
413 "");
414 static_assert(
415 ill_formed<writable_iter_t, decltype(std::declval<vec_type &>().crend())>::
416 value,
417 "");
418
test_iterators()419 void test_iterators()
420 {
421 {
422 vec_type v;
423 v.push_back(3);
424 v.push_back(2);
425 v.push_back(1);
426
427 static_assert(
428 std::is_same<decltype(v.begin()), vec_type::iterator>::value, "");
429 static_assert(
430 std::is_same<decltype(v.end()), vec_type::iterator>::value, "");
431 static_assert(
432 std::is_same<decltype(v.cbegin()), vec_type::const_iterator>::value,
433 "");
434 static_assert(
435 std::is_same<decltype(v.cend()), vec_type::const_iterator>::value,
436 "");
437 static_assert(
438 std::is_same<decltype(v.rbegin()), vec_type::reverse_iterator>::
439 value,
440 "");
441 static_assert(
442 std::is_same<decltype(v.rbegin()), vec_type::reverse_iterator>::
443 value,
444 "");
445 static_assert(
446 std::is_same<
447 decltype(v.crbegin()),
448 vec_type::const_reverse_iterator>::value,
449 "");
450 static_assert(
451 std::is_same<
452 decltype(v.crbegin()),
453 vec_type::const_reverse_iterator>::value,
454 "");
455
456 std::array<int, 3> const a = {{3, 2, 1}};
457 std::array<int, 3> const ra = {{1, 2, 3}};
458
459 BOOST_TEST(std::equal(v.begin(), v.end(), a.begin(), a.end()));
460 BOOST_TEST(std::equal(v.cbegin(), v.cend(), a.begin(), a.end()));
461
462 BOOST_TEST(std::equal(v.rbegin(), v.rend(), ra.begin(), ra.end()));
463 BOOST_TEST(std::equal(v.crbegin(), v.crend(), ra.begin(), ra.end()));
464
465 *v.begin() = 8;
466 *v.rbegin() = 9;
467 BOOST_TEST(v[0] == 8);
468 BOOST_TEST(v[2] == 9);
469 }
470
471 {
472 vec_type v_;
473 v_.push_back(3);
474 v_.push_back(2);
475 v_.push_back(1);
476 vec_type const & v = v_;
477
478 static_assert(
479 std::is_same<decltype(v.begin()), vec_type::const_iterator>::value,
480 "");
481 static_assert(
482 std::is_same<decltype(v.end()), vec_type::const_iterator>::value,
483 "");
484 static_assert(
485 std::is_same<decltype(v.cbegin()), vec_type::const_iterator>::value,
486 "");
487 static_assert(
488 std::is_same<decltype(v.cend()), vec_type::const_iterator>::value,
489 "");
490 static_assert(
491 std::is_same<
492 decltype(v.rbegin()),
493 vec_type::const_reverse_iterator>::value,
494 "");
495 static_assert(
496 std::is_same<
497 decltype(v.rbegin()),
498 vec_type::const_reverse_iterator>::value,
499 "");
500 static_assert(
501 std::is_same<
502 decltype(v.crbegin()),
503 vec_type::const_reverse_iterator>::value,
504 "");
505 static_assert(
506 std::is_same<
507 decltype(v.crbegin()),
508 vec_type::const_reverse_iterator>::value,
509 "");
510
511 std::array<int, 3> const a = {{3, 2, 1}};
512 std::array<int, 3> const ra = {{1, 2, 3}};
513
514 BOOST_TEST(std::equal(v.begin(), v.end(), a.begin(), a.end()));
515 BOOST_TEST(std::equal(v.cbegin(), v.cend(), a.begin(), a.end()));
516
517 BOOST_TEST(std::equal(v.rbegin(), v.rend(), ra.begin(), ra.end()));
518 BOOST_TEST(std::equal(v.crbegin(), v.crend(), ra.begin(), ra.end()));
519 }
520 }
521
522
test_emplace_insert()523 void test_emplace_insert()
524 {
525 {
526 vec_type v;
527
528 int const i = 0;
529 static_assert(
530 std::is_same<decltype(v.emplace_back(0)), vec_type::reference>::
531 value,
532 "");
533 static_assert(
534 std::is_same<decltype(v.emplace_back(i)), vec_type::reference>::
535 value,
536 "");
537
538 v.emplace_back(i);
539 BOOST_TEST(v.front() == i);
540 BOOST_TEST(v.back() == i);
541
542 v.emplace_back(1);
543 BOOST_TEST(v.front() == i);
544 BOOST_TEST(v.back() == 1);
545
546 v.emplace_back(2);
547 BOOST_TEST(v.front() == i);
548 BOOST_TEST(v.back() == 2);
549
550 BOOST_TEST(v[0] == 0);
551 BOOST_TEST(v[1] == 1);
552 BOOST_TEST(v[2] == 2);
553 }
554
555 {
556 vec_type v;
557 v.push_back(1);
558 v.push_back(2);
559
560 int const i = 0;
561 static_assert(
562 std::is_same<
563 decltype(v.emplace(v.begin(), 0)),
564 vec_type::iterator>::value,
565 "");
566 static_assert(
567 std::is_same<
568 decltype(v.emplace(v.begin(), i)),
569 vec_type::iterator>::value,
570 "");
571
572 v.emplace(v.begin(), i);
573 BOOST_TEST(v[0] == 0);
574 BOOST_TEST(v[1] == 1);
575 BOOST_TEST(v[2] == 2);
576
577 v.emplace(v.end(), 3);
578 BOOST_TEST(v[0] == 0);
579 BOOST_TEST(v[1] == 1);
580 BOOST_TEST(v[2] == 2);
581 BOOST_TEST(v[3] == 3);
582
583 v.emplace(v.begin() + 2, 9);
584 BOOST_TEST(v[0] == 0);
585 BOOST_TEST(v[1] == 1);
586 BOOST_TEST(v[2] == 9);
587 BOOST_TEST(v[3] == 2);
588 BOOST_TEST(v[4] == 3);
589 }
590
591 {
592 vec_type v;
593 v.push_back(1);
594 v.push_back(2);
595
596 std::array<int, 2> a1 = {{0, 0}};
597 std::array<int, 1> a2 = {{3}};
598 std::array<int, 3> a3 = {{9, 9, 9}};
599
600 static_assert(
601 std::is_same<
602 decltype(v.insert(v.begin(), a1.begin(), a1.end())),
603 vec_type::iterator>::value,
604 "");
605
606 auto const it0 = v.insert(v.begin(), a1.begin(), a1.end());
607 BOOST_TEST(v[0] == 0);
608 BOOST_TEST(v[1] == 0);
609 BOOST_TEST(v[2] == 1);
610 BOOST_TEST(v[3] == 2);
611 BOOST_TEST(it0 == v.begin());
612
613 auto const it1 = v.insert(v.end(), a2.begin(), a2.end());
614 BOOST_TEST(v[0] == 0);
615 BOOST_TEST(v[1] == 0);
616 BOOST_TEST(v[2] == 1);
617 BOOST_TEST(v[3] == 2);
618 BOOST_TEST(v[4] == 3);
619 BOOST_TEST(it1 == v.begin() + 4);
620
621 auto const it2 = v.insert(v.begin() + 2, a3.begin(), a3.end());
622 BOOST_TEST(v[0] == 0);
623 BOOST_TEST(v[1] == 0);
624 BOOST_TEST(v[2] == 9);
625 BOOST_TEST(v[3] == 9);
626 BOOST_TEST(v[4] == 9);
627 BOOST_TEST(v[5] == 1);
628 BOOST_TEST(v[6] == 2);
629 BOOST_TEST(v[7] == 3);
630 BOOST_TEST(it2 == v.begin() + 2);
631 }
632
633 {
634 vec_type v;
635 v.push_back(1);
636 v.push_back(2);
637
638 int const i = 0;
639 static_assert(
640 std::is_same<decltype(v.insert(v.begin(), 0)), vec_type::iterator>::
641 value,
642 "");
643 static_assert(
644 std::is_same<decltype(v.insert(v.begin(), i)), vec_type::iterator>::
645 value,
646 "");
647
648 v.emplace(v.begin(), i);
649 BOOST_TEST(v[0] == 0);
650 BOOST_TEST(v[1] == 1);
651 BOOST_TEST(v[2] == 2);
652
653 v.emplace(v.end(), 3);
654 BOOST_TEST(v[0] == 0);
655 BOOST_TEST(v[1] == 1);
656 BOOST_TEST(v[2] == 2);
657 BOOST_TEST(v[3] == 3);
658
659 v.emplace(v.begin() + 2, 9);
660 BOOST_TEST(v[0] == 0);
661 BOOST_TEST(v[1] == 1);
662 BOOST_TEST(v[2] == 9);
663 BOOST_TEST(v[3] == 2);
664 BOOST_TEST(v[4] == 3);
665 }
666
667 #if 0 // Fill-insert is not supported for move-only value_type.
668 {
669 vec_type v;
670 v.push_back(1);
671 v.push_back(2);
672
673 static_assert(
674 std::is_same<
675 decltype(v.insert(v.begin(), 3, 0)),
676 vec_type::iterator>::value,
677 "");
678
679 v.insert(v.begin(), 2, 0);
680 v.insert(v.end(), 1, 3);
681 v.insert(v.begin() + 2, 3, 9);
682 }
683 #endif
684
685 #if 0 // initializer_list-insert is not supported for move-only value_type.
686 {
687 vec_type v;
688 v.push_back(1);
689 v.push_back(2);
690
691 static_assert(
692 std::is_same<
693 decltype(v.insert(v.begin(), std::initializer_list<noncopyable_int>{0, 0})),
694 vec_type::iterator>::value,
695 "");
696
697 v.insert(v.begin(), std::initializer_list<noncopyable_int>{0, 0});
698 v.insert(v.end(), std::initializer_list<noncopyable_int>{3});
699 v.insert(v.begin() + 2, std::initializer_list<noncopyable_int>{9, 9, 9});
700 }
701 #endif
702 }
703
704
test_erase()705 void test_erase()
706 {
707 {
708 vec_type v;
709 v.push_back(3);
710 v.push_back(2);
711 v.push_back(1);
712
713 static_assert(
714 std::is_same<
715 decltype(v.erase(v.begin(), v.end())),
716 vec_type::iterator>::value,
717 "");
718 static_assert(
719 std::is_same<decltype(v.erase(v.begin())), vec_type::iterator>::
720 value,
721 "");
722
723 v.erase(v.begin(), v.end());
724 BOOST_TEST(v.empty());
725 BOOST_TEST(v.size() == 0u);
726 }
727
728 {
729 vec_type v;
730 v.push_back(3);
731 v.push_back(2);
732 v.push_back(1);
733 v.erase(v.begin() + 1, v.end());
734 BOOST_TEST(!v.empty());
735 BOOST_TEST(v.size() == 1u);
736 BOOST_TEST(v[0] == 3);
737 }
738
739 {
740 vec_type v;
741 v.push_back(3);
742 v.push_back(2);
743 v.push_back(1);
744 v.erase(v.begin(), v.end() - 1);
745 BOOST_TEST(!v.empty());
746 BOOST_TEST(v.size() == 1u);
747 BOOST_TEST(v[0] == 1);
748 }
749
750 {
751 vec_type v;
752 v.push_back(3);
753 v.push_back(2);
754 v.push_back(1);
755 v.erase(v.begin());
756 BOOST_TEST(!v.empty());
757 BOOST_TEST(v.size() == 2u);
758 BOOST_TEST(v[0] == 2);
759 BOOST_TEST(v[1] == 1);
760 }
761
762 {
763 vec_type v;
764 v.push_back(3);
765 v.push_back(2);
766 v.push_back(1);
767 v.erase(v.begin() + 1);
768 BOOST_TEST(!v.empty());
769 BOOST_TEST(v.size() == 2u);
770 BOOST_TEST(v[0] == 3);
771 BOOST_TEST(v[1] == 1);
772 }
773
774 {
775 vec_type v;
776 v.push_back(3);
777 v.push_back(2);
778 v.push_back(1);
779 v.erase(v.begin() + 2);
780 BOOST_TEST(!v.empty());
781 BOOST_TEST(v.size() == 2u);
782 BOOST_TEST(v[0] == 3);
783 BOOST_TEST(v[1] == 2);
784 }
785 }
786
787 template<
788 typename Container,
789 typename ValueType = typename Container::value_type>
790 using lvalue_push_front_t = decltype(
791 std::declval<Container &>().push_front(std::declval<ValueType const &>()));
792 template<
793 typename Container,
794 typename ValueType = typename Container::value_type>
795 using rvalue_push_front_t = decltype(std::declval<Container &>().push_front(0));
796 template<typename Container>
797 using pop_front_t = decltype(std::declval<Container &>().pop_front());
798
799 static_assert(ill_formed<lvalue_push_front_t, vec_type>::value, "");
800 static_assert(ill_formed<rvalue_push_front_t, vec_type>::value, "");
801 static_assert(ill_formed<pop_front_t, vec_type>::value, "");
802
test_front_back()803 void test_front_back()
804 {
805 {
806 vec_type v;
807
808 int const i = 0;
809 static_assert(std::is_same<decltype(v.push_back(0)), void>::value, "");
810 static_assert(std::is_same<decltype(v.push_back(i)), void>::value, "");
811 static_assert(std::is_same<decltype(v.pop_back()), void>::value, "");
812
813 v.emplace_back(i);
814 BOOST_TEST(v.front() == i);
815 BOOST_TEST(v.back() == i);
816
817 v.emplace_back(1);
818 BOOST_TEST(v.front() == i);
819 BOOST_TEST(v.back() == 1);
820
821 v.emplace_back(2);
822 BOOST_TEST(v.front() == i);
823 BOOST_TEST(v.back() == 2);
824
825 static_assert(std::is_same<decltype(v.front()), noncopyable_int &>::value, "");
826 static_assert(std::is_same<decltype(v.back()), noncopyable_int &>::value, "");
827
828 v.front() = 9;
829 v.back() = 8;
830 BOOST_TEST(v[0] == 9);
831 BOOST_TEST(v[1] == 1);
832 BOOST_TEST(v[2] == 8);
833
834 v.pop_back();
835 BOOST_TEST(v[0] == 9);
836 BOOST_TEST(v[1] == 1);
837 }
838
839 {
840 vec_type v_;
841 v_.push_back(3);
842 v_.push_back(2);
843 v_.push_back(1);
844 vec_type const & v = v_;
845 BOOST_TEST(v.front() == 3);
846 BOOST_TEST(v.back() == 1);
847
848 static_assert(
849 std::is_same<decltype(v.front()), noncopyable_int const &>::value, "");
850 static_assert(std::is_same<decltype(v.back()), noncopyable_int const &>::value, "");
851 }
852 }
853
854
test_data_index_at()855 void test_data_index_at()
856 {
857 {
858 vec_type v;
859 v.push_back(3);
860 v.push_back(2);
861 v.push_back(1);
862 BOOST_TEST(v.data()[0] == 3);
863 BOOST_TEST(v.data()[1] == 2);
864 BOOST_TEST(v.data()[2] == 1);
865 BOOST_TEST(v[0] == 3);
866 BOOST_TEST(v[1] == 2);
867 BOOST_TEST(v[2] == 1);
868 BOOST_TEST_NO_THROW(v.at(0));
869 BOOST_TEST_NO_THROW(v.at(1));
870 BOOST_TEST_NO_THROW(v.at(2));
871 BOOST_TEST_THROWS(v.at(3), std::out_of_range);
872
873 static_assert(std::is_same<decltype(v.data()), noncopyable_int *>::value, "");
874 static_assert(std::is_same<decltype(v[0]), noncopyable_int &>::value, "");
875 static_assert(std::is_same<decltype(v.at(0)), noncopyable_int &>::value, "");
876
877 v[0] = 8;
878 v.at(1) = 9;
879 BOOST_TEST(v[0] == 8);
880 BOOST_TEST(v[1] == 9);
881 BOOST_TEST(v[2] == 1);
882 }
883
884 {
885 vec_type v_;
886 v_.push_back(3);
887 v_.push_back(2);
888 v_.push_back(1);
889 vec_type const & v = v_;
890 BOOST_TEST(v.data()[0] == 3);
891 BOOST_TEST(v.data()[1] == 2);
892 BOOST_TEST(v.data()[2] == 1);
893 BOOST_TEST(v[0] == 3);
894 BOOST_TEST(v[1] == 2);
895 BOOST_TEST(v[2] == 1);
896 BOOST_TEST_NO_THROW(v.at(0));
897 BOOST_TEST_NO_THROW(v.at(1));
898 BOOST_TEST_NO_THROW(v.at(2));
899 BOOST_TEST_THROWS(v.at(3), std::out_of_range);
900
901 static_assert(std::is_same<decltype(v.data()), noncopyable_int const *>::value, "");
902 static_assert(std::is_same<decltype(v[0]), noncopyable_int const &>::value, "");
903 static_assert(std::is_same<decltype(v.at(0)), noncopyable_int const &>::value, "");
904 }
905 }
906
main()907 int main()
908 {
909 test_default_ctor();
910 test_other_ctors_assign_ctor();
911 test_resize();
912 test_assignment_copy_move_equality();
913 test_comparisons();
914 test_swap();
915 test_iterators();
916 test_emplace_insert();
917 test_erase();
918 test_front_back();
919 test_data_index_at();
920 return boost::report_errors();
921 }
922