1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // <vector>
10
11 // void reserve(size_type n);
12
13 #include <vector>
14 #include <cassert>
15 #include <stdexcept>
16 #include "test_macros.h"
17 #include "test_allocator.h"
18 #include "min_allocator.h"
19 #include "asan_testing.h"
20
tests()21 TEST_CONSTEXPR_CXX20 bool tests() {
22 {
23 std::vector<int> v;
24 v.reserve(10);
25 assert(v.capacity() >= 10);
26 assert(is_contiguous_container_asan_correct(v));
27 }
28 {
29 std::vector<int> v(100);
30 assert(v.capacity() == 100);
31 v.reserve(50);
32 assert(v.size() == 100);
33 assert(v.capacity() == 100);
34 v.reserve(150);
35 assert(v.size() == 100);
36 assert(v.capacity() == 150);
37 assert(is_contiguous_container_asan_correct(v));
38 }
39 {
40 // Add 1 for implementations that dynamically allocate a container proxy.
41 std::vector<int, limited_allocator<int, 250 + 1> > v(100);
42 assert(v.capacity() == 100);
43 v.reserve(50);
44 assert(v.size() == 100);
45 assert(v.capacity() == 100);
46 v.reserve(150);
47 assert(v.size() == 100);
48 assert(v.capacity() == 150);
49 assert(is_contiguous_container_asan_correct(v));
50 }
51 #ifndef TEST_HAS_NO_EXCEPTIONS
52 if (!TEST_IS_CONSTANT_EVALUATED) {
53 std::vector<int> v;
54 size_t sz = v.max_size() + 1;
55
56 try {
57 v.reserve(sz);
58 assert(false);
59 } catch (const std::length_error&) {
60 assert(v.size() == 0);
61 assert(v.capacity() == 0);
62 }
63 }
64 if (!TEST_IS_CONSTANT_EVALUATED) {
65 std::vector<int> v(10, 42);
66 int* previous_data = v.data();
67 size_t previous_capacity = v.capacity();
68 size_t sz = v.max_size() + 1;
69
70 try {
71 v.reserve(sz);
72 assert(false);
73 } catch (std::length_error&) {
74 assert(v.size() == 10);
75 assert(v.capacity() == previous_capacity);
76 assert(v.data() == previous_data);
77
78 for (int i = 0; i < 10; ++i) {
79 assert(v[i] == 42);
80 }
81 }
82 }
83 #endif
84 #if TEST_STD_VER >= 11
85 {
86 std::vector<int, min_allocator<int>> v;
87 v.reserve(10);
88 assert(v.capacity() >= 10);
89 assert(is_contiguous_container_asan_correct(v));
90 }
91 {
92 std::vector<int, min_allocator<int>> v(100);
93 assert(v.capacity() == 100);
94 v.reserve(50);
95 assert(v.size() == 100);
96 assert(v.capacity() == 100);
97 v.reserve(150);
98 assert(v.size() == 100);
99 assert(v.capacity() == 150);
100 assert(is_contiguous_container_asan_correct(v));
101 }
102 #endif
103 #ifndef TEST_HAS_NO_EXCEPTIONS
104 if (!TEST_IS_CONSTANT_EVALUATED) {
105 std::vector<int, limited_allocator<int, 100> > v;
106 v.reserve(50);
107 assert(v.capacity() == 50);
108 assert(is_contiguous_container_asan_correct(v));
109 try {
110 v.reserve(101);
111 assert(false);
112 } catch (const std::length_error&) {
113 // no-op
114 }
115 assert(v.capacity() == 50);
116 assert(is_contiguous_container_asan_correct(v));
117 }
118 #endif
119
120 return true;
121 }
122
main(int,char **)123 int main(int, char**)
124 {
125 tests();
126
127 #if TEST_STD_VER > 17
128 static_assert(tests());
129 #endif
130
131 return 0;
132 }
133