1 /*
2 * Copyright (C) 2009 The Android Open Source Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include "../include/vector"
30 #ifndef ANDROID_ASTL_VECTOR__
31 #error "Wrong header included!!"
32 #endif
33 #include <climits>
34 #include <cstring>
35 #include "common.h"
36
37 namespace android {
38 using std::vector;
39 static const size_t kExponentialFactor = 2;
testConstructorInt()40 bool testConstructorInt()
41 {
42 {
43 vector<int> vec1;
44 EXPECT_TRUE(vec1.empty());
45 EXPECT_TRUE(vec1.size() == 0);
46 EXPECT_TRUE(vec1.capacity() == 0);
47 }
48 {
49 vector<int> vec2(100);
50 EXPECT_TRUE(!vec2.empty());
51 EXPECT_TRUE(vec2.size() == 100);
52 EXPECT_TRUE(vec2.capacity() == 100);
53 for (size_t i = 0; i < 100; ++i)
54 {
55 EXPECT_TRUE(vec2[i] == 0);
56 }
57 }
58 {
59 vector<int> vec3(200, 0xaa);
60 EXPECT_TRUE(!vec3.empty());
61 EXPECT_TRUE(vec3.size() == 200);
62 EXPECT_TRUE(vec3.capacity() == 200);
63 for (size_t i = 0; i < 200; ++i)
64 {
65 EXPECT_TRUE(vec3[i] == 0xaa);
66 }
67 }
68 return true;
69 }
70
71 typedef enum { ONE = 10, TWO} TestEnum;
72
73 template<typename T> struct A { };
74 struct B { };
75
testConstructorRepeat()76 bool testConstructorRepeat()
77 {
78 {
79 const vector<int> vec1(100, 10);
80
81 EXPECT_TRUE(vec1.end() - vec1.begin() == 100);
82 for (int i = 0; i < 100; ++i)
83 {
84 EXPECT_TRUE(vec1[i] == 10);
85 }
86 }
87 {
88 const vector<float> vec2(100, 10.0f);
89
90 for (int i = 0; i < 100; ++i)
91 {
92 EXPECT_TRUE(vec2[i] == 10.0f);
93 }
94 }
95 {
96 const vector<TestEnum> vec3(100, ONE);
97
98 for (int i = 0; i < 100; ++i)
99 {
100 EXPECT_TRUE(vec3[i] == ONE);
101 }
102 }
103 {
104 const vector< A<B> > vec4;
105 const vector< A<B> > vec5(10);
106
107 EXPECT_TRUE(vec4.size() == 0);
108 EXPECT_TRUE(vec5.size() == 10);
109 }
110 return true;
111 }
112
113
testReserve()114 bool testReserve()
115 {
116 { // basic reserve + shrink.
117 vector<int> vec1(100, 10);
118
119 EXPECT_TRUE(vec1.capacity() == 100);
120 EXPECT_TRUE(vec1.reserve(200));
121 EXPECT_TRUE(vec1.capacity() == 200);
122 EXPECT_TRUE(vec1.size() == 100);
123
124 EXPECT_TRUE(vec1.reserve());
125 EXPECT_TRUE(vec1.capacity() == 100);
126 EXPECT_TRUE(vec1.size() == 100);
127 }
128 {
129 vector<int> vec2;
130
131 EXPECT_TRUE(vec2.capacity() == 0);
132 EXPECT_TRUE(vec2.reserve());
133 EXPECT_TRUE(vec2.capacity() == 0);
134
135 vec2.reserve(200);
136 EXPECT_TRUE(vec2.capacity() == 200);
137 vec2.reserve();
138 EXPECT_TRUE(vec2.capacity() == 0);
139 vec2.push_back(3);
140 vec2.reserve();
141 EXPECT_TRUE(vec2.capacity() == 1);
142 }
143 {
144 vector<int> vec3;
145
146 vec3.push_back(5);
147 vec3.reserve();
148 EXPECT_TRUE(vec3.capacity() == 1);
149 vec3.push_back(3);
150 EXPECT_TRUE(vec3.capacity() == kExponentialFactor);
151 while (vec3.size() < kExponentialFactor)
152 vec3.push_back(3);
153
154 EXPECT_TRUE(vec3.size() == kExponentialFactor);
155 EXPECT_TRUE(vec3.capacity() == kExponentialFactor);
156
157 // exp increment.
158 vec3.push_back(10);
159 EXPECT_TRUE(vec3.capacity() == kExponentialFactor * kExponentialFactor);
160 }
161 {
162 CopyCounter c;
163
164 c.mCount = 0;
165 vector<CopyCounter> vec4(100, c);
166 EXPECT_TRUE(c.mCount == 100);
167 // Resizing does not do any copy via the copy assignement op.
168 vec4.reserve(1000);
169 EXPECT_TRUE(c.mCount == 200);
170 vec4.reserve(50); // reserving less than length is a nop.
171 EXPECT_TRUE(c.mCount == 200);
172 }
173 {
174 vector<unsigned short> vec5;
175
176 EXPECT_TRUE(!vec5.reserve(vec5.max_size() + 1));
177 EXPECT_TRUE(vec5.capacity() == 0);
178 }
179 return true;
180 }
181
182
testPushBack()183 bool testPushBack()
184 {
185 {
186 vector<CtorDtorCounter> vec1;
187 CtorDtorCounter c;
188
189 c.reset();
190 for (int i = 0; i < 1000; ++i)
191 {
192 vec1.push_back(c);
193 }
194 EXPECT_TRUE(vec1.capacity() == 1024);
195 EXPECT_TRUE(vec1.size() == 1000);
196 EXPECT_TRUE(c.mAssignCount == 1000);
197 // Due to the multiple augmentation of the capacity, the copy
198 // constructor has been invoked.
199 EXPECT_TRUE(c.mCopyCtorCount > 0);
200 EXPECT_TRUE(c.mCtorCount == 0);
201 }
202 {
203 vector<int> vec2;
204
205 vec2.push_back(10);
206 EXPECT_TRUE(vec2.front() == 10);
207 EXPECT_TRUE(vec2.back() == 10);
208 EXPECT_TRUE(vec2.size() == 1);
209 vec2.push_back(20);
210 EXPECT_TRUE(vec2.front() == 10);
211 EXPECT_TRUE(vec2.back() == 20);
212 EXPECT_TRUE(vec2.size() == 2);
213 }
214 return true;
215 }
216
217
testPopBack()218 bool testPopBack()
219 {
220 vector<int> vec1(10, 0xdeadbeef);;
221
222 EXPECT_TRUE(vec1.capacity() == 10);
223 EXPECT_TRUE(vec1.size() == 10);
224
225 for(size_t i = 10; i > 0; --i)
226 {
227 EXPECT_TRUE(vec1.capacity() == 10);
228 EXPECT_TRUE(vec1.size() == i);
229 vec1.pop_back();
230 }
231 EXPECT_TRUE(vec1.empty());
232 EXPECT_TRUE(vec1.begin() == vec1.end());
233 vec1.pop_back(); // pop_back on empty vector
234 EXPECT_TRUE(vec1.size() == 0);
235 EXPECT_TRUE(vec1.capacity() == 10);
236
237 vec1.clear();
238 vec1.pop_back(); // pop_back on empty vector
239 EXPECT_TRUE(vec1.size() == 0);
240 EXPECT_TRUE(vec1.capacity() == 0);
241 EXPECT_TRUE(vec1.begin() == vec1.end());
242 EXPECT_TRUE(vec1.begin() == NULL);
243
244 CtorDtorCounter instance;
245 vector<CtorDtorCounter> vec2(10, instance);
246
247 CtorDtorCounter::reset();
248 for (int i = 0; i < 10; ++i)
249 {
250 vec2.pop_back();
251 }
252 EXPECT_TRUE(vec2.size() == 0);
253 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 10);
254 return true;
255 }
256
257
testSwap()258 bool testSwap()
259 {
260 vector<int> vec1(100, 10);
261 vector<int> vec2;
262
263 vec1.swap(vec2);
264
265 EXPECT_TRUE(vec1.capacity() == 0);
266 EXPECT_TRUE(vec2.capacity() == 100);
267
268 EXPECT_TRUE(vec1.size() == 0);
269 EXPECT_TRUE(vec2.size() == 100);
270
271 EXPECT_TRUE(vec1.begin() == vec1.end());
272 EXPECT_TRUE(vec2.begin() != vec2.end());
273 return true;
274 }
275
276
testIterators()277 bool testIterators()
278 {
279 vector<int> vec1(10);
280
281 for (size_t i = 0; i < 10; ++i)
282 {
283 vec1[i] = i;
284 }
285
286 vector<int>::iterator i = vec1.begin();
287 for (int c = 0; i != vec1.end(); ++i, ++c)
288 {
289 EXPECT_TRUE(c == *i);
290 }
291
292 vector<int>::const_iterator j = vec1.begin();
293 for (int c = 0; j != vec1.end(); ++j, ++c)
294 {
295 EXPECT_TRUE(c == *j);
296 }
297 return true;
298 }
299
testCtorDtorForNonPod()300 bool testCtorDtorForNonPod()
301 {
302 { // empty vector, no construction should happen.
303 CtorDtorCounter::reset();
304 vector<CtorDtorCounter> vec1;
305
306 EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
307 EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 0);
308 }
309 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
310
311 {
312 CtorDtorCounter instance;
313 EXPECT_TRUE(CtorDtorCounter::mCtorCount == 1);
314 CtorDtorCounter::reset();
315
316 vector<CtorDtorCounter> vec2(200, instance);
317
318 // 200 copies by assignement of the sample instance
319 EXPECT_TRUE(CtorDtorCounter::mAssignCount == 0);
320 EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
321 EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 200);
322 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 0);
323
324 CtorDtorCounter::reset();
325 vec2.reserve(400);
326
327 // 200 moves: 200 copies by copy constructor and 200 destructions.
328 EXPECT_TRUE(CtorDtorCounter::mCopyCtorCount == 200);
329 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 200);
330 EXPECT_TRUE(CtorDtorCounter::mCtorCount == 0);
331 EXPECT_TRUE(CtorDtorCounter::mAssignCount == 0);
332
333 CtorDtorCounter::reset();
334 }
335 // 200 + 1 for the instance
336 EXPECT_TRUE(CtorDtorCounter::mDtorCount == 201);
337 return true;
338 }
339 } // namespace android
340
main(int argc,char ** argv)341 int main(int argc, char **argv)
342 {
343 FAIL_UNLESS(testConstructorInt);
344 FAIL_UNLESS(testConstructorRepeat);
345 FAIL_UNLESS(testReserve);
346 FAIL_UNLESS(testPushBack);
347 FAIL_UNLESS(testPopBack);
348 FAIL_UNLESS(testSwap);
349 FAIL_UNLESS(testIterators);
350 FAIL_UNLESS(testCtorDtorForNonPod);
351 return kPassed;
352 }
353