1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <vector>
11
12 // template <class Iter>
13 // iterator insert(const_iterator position, Iter first, Iter last);
14
15 #if _LIBCPP_DEBUG >= 1
16 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
17 #endif
18
19 #include <vector>
20 #include <cassert>
21 #include "../../../stack_allocator.h"
22 #include "test_iterators.h"
23 #include "min_allocator.h"
24 #include "asan_testing.h"
25
main()26 int main()
27 {
28 {
29 std::vector<int> v(100);
30 int a[] = {1, 2, 3, 4, 5};
31 const int N = sizeof(a)/sizeof(a[0]);
32 std::vector<int>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
33 input_iterator<const int*>(a+N));
34 assert(v.size() == 100 + N);
35 assert(is_contiguous_container_asan_correct(v));
36 assert(i == v.begin() + 10);
37 int j;
38 for (j = 0; j < 10; ++j)
39 assert(v[j] == 0);
40 for (int k = 0; k < N; ++j, ++k)
41 assert(v[j] == a[k]);
42 for (; j < 105; ++j)
43 assert(v[j] == 0);
44 }
45 {
46 std::vector<int> v(100);
47 int a[] = {1, 2, 3, 4, 5};
48 const int N = sizeof(a)/sizeof(a[0]);
49 std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
50 forward_iterator<const int*>(a+N));
51 assert(v.size() == 100 + N);
52 assert(is_contiguous_container_asan_correct(v));
53 assert(i == v.begin() + 10);
54 int j;
55 for (j = 0; j < 10; ++j)
56 assert(v[j] == 0);
57 for (int k = 0; k < N; ++j, ++k)
58 assert(v[j] == a[k]);
59 for (; j < 105; ++j)
60 assert(v[j] == 0);
61 }
62 {
63 std::vector<int> v(100);
64 while(v.size() < v.capacity()) v.push_back(0); // force reallocation
65 size_t sz = v.size();
66 int a[] = {1, 2, 3, 4, 5};
67 const unsigned N = sizeof(a)/sizeof(a[0]);
68 std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
69 forward_iterator<const int*>(a+N));
70 assert(v.size() == sz + N);
71 assert(i == v.begin() + 10);
72 int j;
73 for (j = 0; j < 10; ++j)
74 assert(v[j] == 0);
75 for (int k = 0; k < N; ++j, ++k)
76 assert(v[j] == a[k]);
77 for (; j < v.size(); ++j)
78 assert(v[j] == 0);
79 }
80 {
81 std::vector<int> v(100);
82 v.reserve(128); // force no reallocation
83 size_t sz = v.size();
84 int a[] = {1, 2, 3, 4, 5};
85 const unsigned N = sizeof(a)/sizeof(a[0]);
86 std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
87 forward_iterator<const int*>(a+N));
88 assert(v.size() == sz + N);
89 assert(i == v.begin() + 10);
90 int j;
91 for (j = 0; j < 10; ++j)
92 assert(v[j] == 0);
93 for (int k = 0; k < N; ++j, ++k)
94 assert(v[j] == a[k]);
95 for (; j < v.size(); ++j)
96 assert(v[j] == 0);
97 }
98 {
99 std::vector<int, stack_allocator<int, 308> > v(100);
100 int a[] = {1, 2, 3, 4, 5};
101 const int N = sizeof(a)/sizeof(a[0]);
102 std::vector<int>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
103 input_iterator<const int*>(a+N));
104 assert(v.size() == 100 + N);
105 assert(is_contiguous_container_asan_correct(v));
106 assert(i == v.begin() + 10);
107 int j;
108 for (j = 0; j < 10; ++j)
109 assert(v[j] == 0);
110 for (int k = 0; k < N; ++j, ++k)
111 assert(v[j] == a[k]);
112 for (; j < 105; ++j)
113 assert(v[j] == 0);
114 }
115 {
116 std::vector<int, stack_allocator<int, 300> > v(100);
117 int a[] = {1, 2, 3, 4, 5};
118 const int N = sizeof(a)/sizeof(a[0]);
119 std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
120 forward_iterator<const int*>(a+N));
121 assert(v.size() == 100 + N);
122 assert(is_contiguous_container_asan_correct(v));
123 assert(i == v.begin() + 10);
124 int j;
125 for (j = 0; j < 10; ++j)
126 assert(v[j] == 0);
127 for (int k = 0; k < N; ++j, ++k)
128 assert(v[j] == a[k]);
129 for (; j < 105; ++j)
130 assert(v[j] == 0);
131 }
132 #if _LIBCPP_DEBUG >= 1
133 {
134 std::vector<int> v(100);
135 std::vector<int> v2(100);
136 int a[] = {1, 2, 3, 4, 5};
137 const int N = sizeof(a)/sizeof(a[0]);
138 std::vector<int>::iterator i = v.insert(v2.cbegin() + 10, input_iterator<const int*>(a),
139 input_iterator<const int*>(a+N));
140 assert(false);
141 }
142 #endif
143 #if __cplusplus >= 201103L
144 {
145 std::vector<int, min_allocator<int>> v(100);
146 int a[] = {1, 2, 3, 4, 5};
147 const int N = sizeof(a)/sizeof(a[0]);
148 std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
149 input_iterator<const int*>(a+N));
150 assert(v.size() == 100 + N);
151 assert(is_contiguous_container_asan_correct(v));
152 assert(i == v.begin() + 10);
153 int j;
154 for (j = 0; j < 10; ++j)
155 assert(v[j] == 0);
156 for (int k = 0; k < N; ++j, ++k)
157 assert(v[j] == a[k]);
158 for (; j < 105; ++j)
159 assert(v[j] == 0);
160 }
161 {
162 std::vector<int, min_allocator<int>> v(100);
163 int a[] = {1, 2, 3, 4, 5};
164 const int N = sizeof(a)/sizeof(a[0]);
165 std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
166 forward_iterator<const int*>(a+N));
167 assert(v.size() == 100 + N);
168 assert(is_contiguous_container_asan_correct(v));
169 assert(i == v.begin() + 10);
170 int j;
171 for (j = 0; j < 10; ++j)
172 assert(v[j] == 0);
173 for (int k = 0; k < N; ++j, ++k)
174 assert(v[j] == a[k]);
175 for (; j < 105; ++j)
176 assert(v[j] == 0);
177 }
178 #if _LIBCPP_DEBUG >= 1
179 {
180 std::vector<int, min_allocator<int>> v(100);
181 std::vector<int, min_allocator<int>> v2(100);
182 int a[] = {1, 2, 3, 4, 5};
183 const int N = sizeof(a)/sizeof(a[0]);
184 std::vector<int, min_allocator<int>>::iterator i = v.insert(v2.cbegin() + 10, input_iterator<const int*>(a),
185 input_iterator<const int*>(a+N));
186 assert(false);
187 }
188 #endif
189 #endif
190 }
191