]>
Commit | Line | Data |
---|---|---|
20effc67 TL |
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 | // Instantiate all the members we can. | |
15 | template struct static_vector<int, 1024>; | |
16 | ||
17 | using vec_type = static_vector<int, 10>; | |
18 | ||
19 | ||
20 | void test_default_ctor() | |
21 | { | |
22 | vec_type v; | |
23 | BOOST_TEST(v.empty()); | |
24 | BOOST_TEST(v.size() == 0u); | |
25 | ||
26 | BOOST_TEST(v.max_size() == 10u); | |
27 | BOOST_TEST(v.capacity() == 10u); | |
28 | ||
29 | BOOST_TEST(v == v); | |
30 | BOOST_TEST(v <= v); | |
31 | BOOST_TEST(v >= v); | |
32 | ||
33 | BOOST_TEST_THROWS(v.at(0), std::out_of_range); | |
34 | ||
35 | vec_type const & cv = v; | |
36 | BOOST_TEST(cv.empty()); | |
37 | BOOST_TEST(cv.size() == 0u); | |
38 | ||
39 | BOOST_TEST(cv.max_size() == 10u); | |
40 | BOOST_TEST(cv.capacity() == 10u); | |
41 | ||
42 | BOOST_TEST(cv == cv); | |
43 | BOOST_TEST(cv <= cv); | |
44 | BOOST_TEST(cv >= cv); | |
45 | ||
46 | BOOST_TEST_THROWS(cv.at(0), std::out_of_range); | |
47 | } | |
48 | ||
49 | ||
50 | void test_other_ctors_assign_ctor() | |
51 | { | |
52 | { | |
53 | vec_type v(3); | |
54 | BOOST_TEST(!v.empty()); | |
55 | BOOST_TEST(v.size() == 3u); | |
56 | ||
57 | vec_type v2(std::initializer_list<int>{0, 0, 0}); | |
58 | BOOST_TEST(v == v2); | |
59 | } | |
60 | ||
61 | { | |
62 | std::initializer_list<int> il{3, 2, 1}; | |
63 | vec_type v(il); | |
64 | BOOST_TEST(!v.empty()); | |
65 | BOOST_TEST(v.size() == 3u); | |
66 | ||
67 | static_assert(std::is_same<decltype(v = il), vec_type &>::value, ""); | |
68 | ||
69 | vec_type v2; | |
70 | v2 = il; | |
71 | BOOST_TEST(v == v2); | |
72 | } | |
73 | ||
74 | { | |
75 | std::initializer_list<int> il{3, 2, 1}; | |
76 | vec_type v; | |
77 | v.assign(il); | |
78 | BOOST_TEST(!v.empty()); | |
79 | BOOST_TEST(v.size() == 3u); | |
80 | ||
81 | static_assert(std::is_same<decltype(v.assign(il)), void>::value, ""); | |
82 | ||
83 | vec_type v2; | |
84 | v2 = il; | |
85 | BOOST_TEST(v == v2); | |
86 | } | |
87 | ||
88 | { | |
89 | vec_type v(3, 4); | |
90 | BOOST_TEST(!v.empty()); | |
91 | BOOST_TEST(v.size() == 3u); | |
92 | ||
93 | vec_type v2 = {4, 4, 4}; | |
94 | BOOST_TEST(v == v2); | |
95 | } | |
96 | ||
97 | { | |
98 | vec_type v; | |
99 | v.assign(3, 4); | |
100 | BOOST_TEST(!v.empty()); | |
101 | BOOST_TEST(v.size() == 3u); | |
102 | ||
103 | static_assert(std::is_same<decltype(v.assign(3, 4)), void>::value, ""); | |
104 | ||
105 | vec_type v2 = {4, 4, 4}; | |
106 | BOOST_TEST(v == v2); | |
107 | } | |
108 | ||
109 | { | |
110 | std::array<int, 3> a = {{1, 2, 3}}; | |
111 | ||
112 | vec_type v(a.begin(), a.end()); | |
113 | BOOST_TEST(!v.empty()); | |
114 | BOOST_TEST(v.size() == 3u); | |
115 | ||
116 | vec_type v2 = {1, 2, 3}; | |
117 | BOOST_TEST(v == v2); | |
118 | } | |
119 | ||
120 | { | |
121 | std::array<int, 3> a = {{1, 2, 3}}; | |
122 | ||
123 | vec_type v; | |
124 | v.assign(a.begin(), a.end()); | |
125 | BOOST_TEST(!v.empty()); | |
126 | BOOST_TEST(v.size() == 3u); | |
127 | ||
128 | static_assert( | |
129 | std::is_same<decltype(v.assign(a.begin(), a.end())), void>::value, | |
130 | ""); | |
131 | ||
132 | vec_type v2 = {1, 2, 3}; | |
133 | BOOST_TEST(v == v2); | |
134 | } | |
135 | } | |
136 | ||
137 | ||
138 | void test_resize() | |
139 | { | |
140 | { | |
141 | vec_type v; | |
142 | ||
143 | static_assert(std::is_same<decltype(v.resize(1)), void>::value, ""); | |
144 | ||
145 | v.resize(3); | |
146 | BOOST_TEST(v == vec_type(3)); | |
147 | ||
148 | v.resize(6); | |
149 | BOOST_TEST(v == vec_type(6)); | |
150 | } | |
151 | ||
152 | { | |
153 | vec_type v(6); | |
154 | ||
155 | v.resize(3); | |
156 | BOOST_TEST(v == vec_type(3)); | |
157 | ||
158 | v.resize(0); | |
159 | BOOST_TEST(v == vec_type{}); | |
160 | } | |
161 | } | |
162 | ||
163 | ||
164 | void test_assignment_copy_move_equality() | |
165 | { | |
166 | { | |
167 | vec_type v2 = {4, 4, 4}; | |
168 | ||
169 | vec_type v(v2); | |
170 | BOOST_TEST(v == v2); | |
171 | } | |
172 | ||
173 | { | |
174 | vec_type v; | |
175 | vec_type v2 = {4, 4, 4}; | |
176 | ||
177 | static_assert(std::is_same<decltype(v = v2), vec_type &>::value, ""); | |
178 | static_assert( | |
179 | std::is_same<decltype(v = std::move(v2)), vec_type &>::value, ""); | |
180 | ||
181 | v = v2; | |
182 | BOOST_TEST(v == v2); | |
183 | } | |
184 | ||
185 | { | |
186 | vec_type v2 = {4, 4, 4}; | |
187 | ||
188 | vec_type v(std::move(v2)); | |
189 | BOOST_TEST(v == (vec_type(3, 4))); | |
190 | BOOST_TEST(v2.empty()); | |
191 | } | |
192 | ||
193 | { | |
194 | vec_type v; | |
195 | vec_type v2 = {4, 4, 4}; | |
196 | ||
197 | v = std::move(v2); | |
198 | BOOST_TEST(v == (vec_type(3, 4))); | |
199 | BOOST_TEST(v2.empty()); | |
200 | } | |
201 | } | |
202 | ||
203 | ||
204 | void test_comparisons() | |
205 | { | |
206 | vec_type sm = {1, 2, 3}; | |
207 | vec_type md = {1, 2, 3, 4}; | |
208 | vec_type lg = {1, 2, 3, 4, 5}; | |
209 | ||
210 | BOOST_TEST(sm == sm); | |
211 | BOOST_TEST(!(sm == md)); | |
212 | BOOST_TEST(!(sm == lg)); | |
213 | ||
214 | BOOST_TEST(!(sm != sm)); | |
215 | BOOST_TEST(sm != md); | |
216 | BOOST_TEST(sm != lg); | |
217 | ||
218 | BOOST_TEST(!(sm < sm)); | |
219 | BOOST_TEST(sm < md); | |
220 | BOOST_TEST(sm < lg); | |
221 | ||
222 | BOOST_TEST(sm <= sm); | |
223 | BOOST_TEST(sm <= md); | |
224 | BOOST_TEST(sm <= lg); | |
225 | ||
226 | BOOST_TEST(!(sm > sm)); | |
227 | BOOST_TEST(!(sm > md)); | |
228 | BOOST_TEST(!(sm > lg)); | |
229 | ||
230 | BOOST_TEST(sm >= sm); | |
231 | BOOST_TEST(!(sm >= md)); | |
232 | BOOST_TEST(!(sm >= lg)); | |
233 | ||
234 | ||
235 | BOOST_TEST(!(md == sm)); | |
236 | BOOST_TEST(md == md); | |
237 | BOOST_TEST(!(md == lg)); | |
238 | ||
239 | BOOST_TEST(!(md < sm)); | |
240 | BOOST_TEST(!(md < md)); | |
241 | BOOST_TEST(md < lg); | |
242 | ||
243 | BOOST_TEST(!(md <= sm)); | |
244 | BOOST_TEST(md <= md); | |
245 | BOOST_TEST(md <= lg); | |
246 | ||
247 | BOOST_TEST(md > sm); | |
248 | BOOST_TEST(!(md > md)); | |
249 | BOOST_TEST(!(md > lg)); | |
250 | ||
251 | BOOST_TEST(md >= sm); | |
252 | BOOST_TEST(md >= md); | |
253 | BOOST_TEST(!(md >= lg)); | |
254 | ||
255 | ||
256 | BOOST_TEST(!(lg == sm)); | |
257 | BOOST_TEST(!(lg == md)); | |
258 | BOOST_TEST(lg == lg); | |
259 | ||
260 | BOOST_TEST(!(lg < sm)); | |
261 | BOOST_TEST(!(lg < md)); | |
262 | BOOST_TEST(!(lg < lg)); | |
263 | ||
264 | BOOST_TEST(!(lg <= sm)); | |
265 | BOOST_TEST(!(lg <= md)); | |
266 | BOOST_TEST(lg <= lg); | |
267 | ||
268 | BOOST_TEST(lg > sm); | |
269 | BOOST_TEST(lg > md); | |
270 | BOOST_TEST(!(lg > lg)); | |
271 | ||
272 | BOOST_TEST(lg >= sm); | |
273 | BOOST_TEST(lg >= md); | |
274 | BOOST_TEST(lg >= lg); | |
275 | } | |
276 | ||
277 | ||
278 | void test_swap() | |
279 | { | |
280 | { | |
281 | vec_type v1(3, 4); | |
282 | vec_type v2(4, 3); | |
283 | ||
284 | static_assert(std::is_same<decltype(v1.swap(v2)), void>::value, ""); | |
285 | static_assert(std::is_same<decltype(swap(v1, v2)), void>::value, ""); | |
286 | ||
287 | v1.swap(v2); | |
288 | ||
289 | BOOST_TEST(v1.size() == 4u); | |
290 | BOOST_TEST(v2.size() == 3u); | |
291 | ||
292 | BOOST_TEST(v1 == vec_type(4, 3)); | |
293 | BOOST_TEST(v2 == vec_type(3, 4)); | |
294 | } | |
295 | ||
296 | { | |
297 | vec_type v1(3, 4); | |
298 | vec_type v2(4, 3); | |
299 | ||
300 | swap(v1, v2); | |
301 | ||
302 | BOOST_TEST(v1.size() == 4u); | |
303 | BOOST_TEST(v2.size() == 3u); | |
304 | ||
305 | BOOST_TEST(v1 == vec_type(4, 3)); | |
306 | BOOST_TEST(v2 == vec_type(3, 4)); | |
307 | } | |
308 | } | |
309 | ||
310 | template<typename Iter> | |
311 | using writable_iter_t = decltype( | |
312 | *std::declval<Iter>() = | |
313 | std::declval<typename std::iterator_traits<Iter>::value_type>()); | |
314 | ||
315 | static_assert( | |
316 | ill_formed< | |
317 | writable_iter_t, | |
318 | decltype(std::declval<vec_type const &>().begin())>::value, | |
319 | ""); | |
320 | static_assert( | |
321 | ill_formed< | |
322 | writable_iter_t, | |
323 | decltype(std::declval<vec_type const &>().end())>::value, | |
324 | ""); | |
325 | static_assert( | |
326 | ill_formed<writable_iter_t, decltype(std::declval<vec_type &>().cbegin())>:: | |
327 | value, | |
328 | ""); | |
329 | static_assert( | |
330 | ill_formed<writable_iter_t, decltype(std::declval<vec_type &>().cend())>:: | |
331 | value, | |
332 | ""); | |
333 | ||
334 | static_assert( | |
335 | ill_formed< | |
336 | writable_iter_t, | |
337 | decltype(std::declval<vec_type const &>().rbegin())>::value, | |
338 | ""); | |
339 | static_assert( | |
340 | ill_formed< | |
341 | writable_iter_t, | |
342 | decltype(std::declval<vec_type const &>().rend())>::value, | |
343 | ""); | |
344 | static_assert( | |
345 | ill_formed< | |
346 | writable_iter_t, | |
347 | decltype(std::declval<vec_type &>().crbegin())>::value, | |
348 | ""); | |
349 | static_assert( | |
350 | ill_formed<writable_iter_t, decltype(std::declval<vec_type &>().crend())>:: | |
351 | value, | |
352 | ""); | |
353 | ||
354 | void test_iterators() | |
355 | { | |
356 | { | |
357 | vec_type v = {3, 2, 1}; | |
358 | ||
359 | static_assert( | |
360 | std::is_same<decltype(v.begin()), vec_type::iterator>::value, ""); | |
361 | static_assert( | |
362 | std::is_same<decltype(v.end()), vec_type::iterator>::value, ""); | |
363 | static_assert( | |
364 | std::is_same<decltype(v.cbegin()), vec_type::const_iterator>::value, | |
365 | ""); | |
366 | static_assert( | |
367 | std::is_same<decltype(v.cend()), vec_type::const_iterator>::value, | |
368 | ""); | |
369 | static_assert( | |
370 | std::is_same<decltype(v.rbegin()), vec_type::reverse_iterator>:: | |
371 | value, | |
372 | ""); | |
373 | static_assert( | |
374 | std::is_same<decltype(v.rbegin()), vec_type::reverse_iterator>:: | |
375 | value, | |
376 | ""); | |
377 | static_assert( | |
378 | std::is_same< | |
379 | decltype(v.crbegin()), | |
380 | vec_type::const_reverse_iterator>::value, | |
381 | ""); | |
382 | static_assert( | |
383 | std::is_same< | |
384 | decltype(v.crbegin()), | |
385 | vec_type::const_reverse_iterator>::value, | |
386 | ""); | |
387 | ||
388 | std::array<int, 3> const a = {{3, 2, 1}}; | |
389 | std::array<int, 3> const ra = {{1, 2, 3}}; | |
390 | ||
391 | BOOST_TEST(std::equal(v.begin(), v.end(), a.begin(), a.end())); | |
392 | BOOST_TEST(std::equal(v.cbegin(), v.cend(), a.begin(), a.end())); | |
393 | ||
394 | BOOST_TEST(std::equal(v.rbegin(), v.rend(), ra.begin(), ra.end())); | |
395 | BOOST_TEST(std::equal(v.crbegin(), v.crend(), ra.begin(), ra.end())); | |
396 | ||
397 | *v.begin() = 8; | |
398 | *v.rbegin() = 9; | |
399 | BOOST_TEST(v == vec_type({8, 2, 9})); | |
400 | } | |
401 | ||
402 | { | |
403 | vec_type const v = {3, 2, 1}; | |
404 | ||
405 | static_assert( | |
406 | std::is_same<decltype(v.begin()), vec_type::const_iterator>::value, | |
407 | ""); | |
408 | static_assert( | |
409 | std::is_same<decltype(v.end()), vec_type::const_iterator>::value, | |
410 | ""); | |
411 | static_assert( | |
412 | std::is_same<decltype(v.cbegin()), vec_type::const_iterator>::value, | |
413 | ""); | |
414 | static_assert( | |
415 | std::is_same<decltype(v.cend()), vec_type::const_iterator>::value, | |
416 | ""); | |
417 | static_assert( | |
418 | std::is_same< | |
419 | decltype(v.rbegin()), | |
420 | vec_type::const_reverse_iterator>::value, | |
421 | ""); | |
422 | static_assert( | |
423 | std::is_same< | |
424 | decltype(v.rbegin()), | |
425 | vec_type::const_reverse_iterator>::value, | |
426 | ""); | |
427 | static_assert( | |
428 | std::is_same< | |
429 | decltype(v.crbegin()), | |
430 | vec_type::const_reverse_iterator>::value, | |
431 | ""); | |
432 | static_assert( | |
433 | std::is_same< | |
434 | decltype(v.crbegin()), | |
435 | vec_type::const_reverse_iterator>::value, | |
436 | ""); | |
437 | ||
438 | std::array<int, 3> const a = {{3, 2, 1}}; | |
439 | std::array<int, 3> const ra = {{1, 2, 3}}; | |
440 | ||
441 | BOOST_TEST(std::equal(v.begin(), v.end(), a.begin(), a.end())); | |
442 | BOOST_TEST(std::equal(v.cbegin(), v.cend(), a.begin(), a.end())); | |
443 | ||
444 | BOOST_TEST(std::equal(v.rbegin(), v.rend(), ra.begin(), ra.end())); | |
445 | BOOST_TEST(std::equal(v.crbegin(), v.crend(), ra.begin(), ra.end())); | |
446 | } | |
447 | } | |
448 | ||
449 | ||
450 | void test_emplace_insert() | |
451 | { | |
452 | { | |
453 | vec_type v; | |
454 | ||
455 | int const i = 0; | |
456 | static_assert( | |
457 | std::is_same<decltype(v.emplace_back(0)), vec_type::reference>:: | |
458 | value, | |
459 | ""); | |
460 | static_assert( | |
461 | std::is_same<decltype(v.emplace_back(i)), vec_type::reference>:: | |
462 | value, | |
463 | ""); | |
464 | ||
465 | v.emplace_back(i); | |
466 | BOOST_TEST(v.front() == i); | |
467 | BOOST_TEST(v.back() == i); | |
468 | ||
469 | v.emplace_back(1); | |
470 | BOOST_TEST(v.front() == i); | |
471 | BOOST_TEST(v.back() == 1); | |
472 | ||
473 | v.emplace_back(2); | |
474 | BOOST_TEST(v.front() == i); | |
475 | BOOST_TEST(v.back() == 2); | |
476 | ||
477 | BOOST_TEST(v == vec_type({0, 1, 2})); | |
478 | } | |
479 | ||
480 | { | |
481 | vec_type v = {1, 2}; | |
482 | ||
483 | int const i = 0; | |
484 | static_assert( | |
485 | std::is_same< | |
486 | decltype(v.emplace(v.begin(), 0)), | |
487 | vec_type::iterator>::value, | |
488 | ""); | |
489 | static_assert( | |
490 | std::is_same< | |
491 | decltype(v.emplace(v.begin(), i)), | |
492 | vec_type::iterator>::value, | |
493 | ""); | |
494 | ||
495 | v.emplace(v.begin(), i); | |
496 | BOOST_TEST(v == vec_type({0, 1, 2})); | |
497 | ||
498 | v.emplace(v.end(), 3); | |
499 | BOOST_TEST(v == vec_type({0, 1, 2, 3})); | |
500 | ||
501 | v.emplace(v.begin() + 2, 9); | |
502 | BOOST_TEST(v == vec_type({0, 1, 9, 2, 3})); | |
503 | } | |
504 | ||
505 | { | |
506 | vec_type v = {1, 2}; | |
507 | ||
508 | std::array<int, 2> a1 = {{0, 0}}; | |
509 | std::array<int, 1> a2 = {{3}}; | |
510 | std::array<int, 3> a3 = {{9, 9, 9}}; | |
511 | ||
512 | static_assert( | |
513 | std::is_same< | |
514 | decltype(v.insert(v.begin(), a1.begin(), a1.end())), | |
515 | vec_type::iterator>::value, | |
516 | ""); | |
517 | ||
518 | auto const it0 = v.insert(v.begin(), a1.begin(), a1.end()); | |
519 | BOOST_TEST(v == vec_type({0, 0, 1, 2})); | |
520 | BOOST_TEST(it0 == v.begin()); | |
521 | ||
522 | auto const it1 = v.insert(v.end(), a2.begin(), a2.end()); | |
523 | BOOST_TEST(v == vec_type({0, 0, 1, 2, 3})); | |
524 | BOOST_TEST(it1 == v.begin() + 4); | |
525 | ||
526 | auto const it2 = v.insert(v.begin() + 2, a3.begin(), a3.end()); | |
527 | BOOST_TEST(v == vec_type({0, 0, 9, 9, 9, 1, 2, 3})); | |
528 | BOOST_TEST(it2 == v.begin() + 2); | |
529 | } | |
530 | ||
531 | { | |
532 | vec_type v = {1, 2}; | |
533 | ||
534 | int const i = 0; | |
535 | static_assert( | |
536 | std::is_same<decltype(v.insert(v.begin(), 0)), vec_type::iterator>:: | |
537 | value, | |
538 | ""); | |
539 | static_assert( | |
540 | std::is_same<decltype(v.insert(v.begin(), i)), vec_type::iterator>:: | |
541 | value, | |
542 | ""); | |
543 | ||
544 | v.insert(v.begin(), i); | |
545 | BOOST_TEST(v == vec_type({0, 1, 2})); | |
546 | ||
547 | v.insert(v.end(), 3); | |
548 | BOOST_TEST(v == vec_type({0, 1, 2, 3})); | |
549 | ||
550 | v.insert(v.begin() + 2, 9); | |
551 | BOOST_TEST(v == vec_type({0, 1, 9, 2, 3})); | |
552 | } | |
553 | ||
554 | { | |
555 | vec_type v = {1, 2}; | |
556 | ||
557 | static_assert( | |
558 | std::is_same< | |
559 | decltype(v.insert(v.begin(), 3, 0)), | |
560 | vec_type::iterator>::value, | |
561 | ""); | |
562 | ||
563 | v.insert(v.begin(), 2, 0); | |
564 | BOOST_TEST(v == vec_type({0, 0, 1, 2})); | |
565 | ||
566 | v.insert(v.end(), 1, 3); | |
567 | BOOST_TEST(v == vec_type({0, 0, 1, 2, 3})); | |
568 | ||
569 | v.insert(v.begin() + 2, 3, 9); | |
570 | BOOST_TEST(v == vec_type({0, 0, 9, 9, 9, 1, 2, 3})); | |
571 | } | |
572 | ||
573 | { | |
574 | vec_type v = {1, 2}; | |
575 | ||
576 | static_assert( | |
577 | std::is_same< | |
578 | decltype(v.insert(v.begin(), std::initializer_list<int>{0, 0})), | |
579 | vec_type::iterator>::value, | |
580 | ""); | |
581 | ||
582 | v.insert(v.begin(), std::initializer_list<int>{0, 0}); | |
583 | BOOST_TEST(v == vec_type({0, 0, 1, 2})); | |
584 | ||
585 | v.insert(v.end(), std::initializer_list<int>{3}); | |
586 | BOOST_TEST(v == vec_type({0, 0, 1, 2, 3})); | |
587 | ||
588 | v.insert(v.begin() + 2, std::initializer_list<int>{9, 9, 9}); | |
589 | BOOST_TEST(v == vec_type({0, 0, 9, 9, 9, 1, 2, 3})); | |
590 | } | |
591 | } | |
592 | ||
593 | ||
594 | void test_erase() | |
595 | { | |
596 | { | |
597 | vec_type v = {3, 2, 1}; | |
598 | ||
599 | static_assert( | |
600 | std::is_same< | |
601 | decltype(v.erase(v.begin(), v.end())), | |
602 | vec_type::iterator>::value, | |
603 | ""); | |
604 | static_assert( | |
605 | std::is_same<decltype(v.erase(v.begin())), vec_type::iterator>:: | |
606 | value, | |
607 | ""); | |
608 | ||
609 | v.erase(v.begin(), v.end()); | |
610 | BOOST_TEST(v.empty()); | |
611 | BOOST_TEST(v.size() == 0u); | |
612 | } | |
613 | ||
614 | { | |
615 | vec_type v = {3, 2, 1}; | |
616 | v.erase(v.begin() + 1, v.end()); | |
617 | BOOST_TEST(!v.empty()); | |
618 | BOOST_TEST(v.size() == 1u); | |
619 | BOOST_TEST(v == vec_type(1, 3)); | |
620 | } | |
621 | ||
622 | { | |
623 | vec_type v = {3, 2, 1}; | |
624 | v.erase(v.begin(), v.end() - 1); | |
625 | BOOST_TEST(!v.empty()); | |
626 | BOOST_TEST(v.size() == 1u); | |
627 | BOOST_TEST(v == vec_type(1, 1)); | |
628 | } | |
629 | ||
630 | { | |
631 | vec_type v = {3, 2, 1}; | |
632 | v.erase(v.begin()); | |
633 | BOOST_TEST(!v.empty()); | |
634 | BOOST_TEST(v.size() == 2u); | |
635 | BOOST_TEST(v == vec_type({2, 1})); | |
636 | } | |
637 | ||
638 | { | |
639 | vec_type v = {3, 2, 1}; | |
640 | v.erase(v.begin() + 1); | |
641 | BOOST_TEST(!v.empty()); | |
642 | BOOST_TEST(v.size() == 2u); | |
643 | BOOST_TEST(v == vec_type({3, 1})); | |
644 | } | |
645 | ||
646 | { | |
647 | vec_type v = {3, 2, 1}; | |
648 | v.erase(v.begin() + 2); | |
649 | BOOST_TEST(!v.empty()); | |
650 | BOOST_TEST(v.size() == 2u); | |
651 | BOOST_TEST(v == vec_type({3, 2})); | |
652 | } | |
653 | } | |
654 | ||
655 | template< | |
656 | typename Container, | |
657 | typename ValueType = typename Container::value_type> | |
658 | using lvalue_push_front_t = decltype( | |
659 | std::declval<Container &>().push_front(std::declval<ValueType const &>())); | |
660 | template< | |
661 | typename Container, | |
662 | typename ValueType = typename Container::value_type> | |
663 | using rvalue_push_front_t = decltype(std::declval<Container &>().push_front(0)); | |
664 | template<typename Container> | |
665 | using pop_front_t = decltype(std::declval<Container &>().pop_front()); | |
666 | ||
667 | static_assert(ill_formed<lvalue_push_front_t, vec_type>::value, ""); | |
668 | static_assert(ill_formed<rvalue_push_front_t, vec_type>::value, ""); | |
669 | static_assert(ill_formed<pop_front_t, vec_type>::value, ""); | |
670 | ||
671 | void test_front_back() | |
672 | { | |
673 | { | |
674 | vec_type v; | |
675 | ||
676 | int const i = 0; | |
677 | static_assert(std::is_same<decltype(v.push_back(0)), void>::value, ""); | |
678 | static_assert(std::is_same<decltype(v.push_back(i)), void>::value, ""); | |
679 | static_assert(std::is_same<decltype(v.pop_back()), void>::value, ""); | |
680 | ||
681 | v.push_back(i); | |
682 | BOOST_TEST(v.front() == i); | |
683 | BOOST_TEST(v.back() == i); | |
684 | ||
685 | v.push_back(1); | |
686 | BOOST_TEST(v.front() == i); | |
687 | BOOST_TEST(v.back() == 1); | |
688 | ||
689 | v.push_back(2); | |
690 | BOOST_TEST(v.front() == i); | |
691 | BOOST_TEST(v.back() == 2); | |
692 | ||
693 | static_assert(std::is_same<decltype(v.front()), int &>::value, ""); | |
694 | static_assert(std::is_same<decltype(v.back()), int &>::value, ""); | |
695 | ||
696 | v.front() = 9; | |
697 | v.back() = 8; | |
698 | BOOST_TEST(v == vec_type({9, 1, 8})); | |
699 | ||
700 | v.pop_back(); | |
701 | BOOST_TEST(v == vec_type({9, 1})); | |
702 | } | |
703 | ||
704 | { | |
705 | vec_type const v = {3, 2, 1}; | |
706 | BOOST_TEST(v.front() == 3); | |
707 | BOOST_TEST(v.back() == 1); | |
708 | ||
709 | static_assert( | |
710 | std::is_same<decltype(v.front()), int const &>::value, ""); | |
711 | static_assert(std::is_same<decltype(v.back()), int const &>::value, ""); | |
712 | } | |
713 | } | |
714 | ||
715 | ||
716 | void test_data_index_at() | |
717 | { | |
718 | { | |
719 | vec_type v = {3, 2, 1}; | |
720 | BOOST_TEST(v.data()[0] == 3); | |
721 | BOOST_TEST(v.data()[1] == 2); | |
722 | BOOST_TEST(v.data()[2] == 1); | |
723 | BOOST_TEST(v[0] == 3); | |
724 | BOOST_TEST(v[1] == 2); | |
725 | BOOST_TEST(v[2] == 1); | |
726 | BOOST_TEST_NO_THROW(v.at(0)); | |
727 | BOOST_TEST_NO_THROW(v.at(1)); | |
728 | BOOST_TEST_NO_THROW(v.at(2)); | |
729 | BOOST_TEST_THROWS(v.at(3), std::out_of_range); | |
730 | ||
731 | static_assert(std::is_same<decltype(v.data()), int *>::value, ""); | |
732 | static_assert(std::is_same<decltype(v[0]), int &>::value, ""); | |
733 | static_assert(std::is_same<decltype(v.at(0)), int &>::value, ""); | |
734 | ||
735 | v[0] = 8; | |
736 | v.at(1) = 9; | |
737 | BOOST_TEST(v == vec_type({8, 9, 1})); | |
738 | } | |
739 | ||
740 | { | |
741 | vec_type const v = {3, 2, 1}; | |
742 | BOOST_TEST(v.data()[0] == 3); | |
743 | BOOST_TEST(v.data()[1] == 2); | |
744 | BOOST_TEST(v.data()[2] == 1); | |
745 | BOOST_TEST(v[0] == 3); | |
746 | BOOST_TEST(v[1] == 2); | |
747 | BOOST_TEST(v[2] == 1); | |
748 | BOOST_TEST_NO_THROW(v.at(0)); | |
749 | BOOST_TEST_NO_THROW(v.at(1)); | |
750 | BOOST_TEST_NO_THROW(v.at(2)); | |
751 | BOOST_TEST_THROWS(v.at(3), std::out_of_range); | |
752 | ||
753 | static_assert(std::is_same<decltype(v.data()), int const *>::value, ""); | |
754 | static_assert(std::is_same<decltype(v[0]), int const &>::value, ""); | |
755 | static_assert(std::is_same<decltype(v.at(0)), int const &>::value, ""); | |
756 | } | |
757 | } | |
758 | ||
759 | int main() | |
760 | { | |
761 | test_default_ctor(); | |
762 | test_other_ctors_assign_ctor(); | |
763 | test_resize(); | |
764 | test_assignment_copy_move_equality(); | |
765 | test_comparisons(); | |
766 | test_swap(); | |
767 | test_iterators(); | |
768 | test_emplace_insert(); | |
769 | test_erase(); | |
770 | test_front_back(); | |
771 | test_data_index_at(); | |
772 | return boost::report_errors(); | |
773 | } |