test_vector.cpp revision 2a4077a9186d6f6dff104bbd1a73484aae6d5c01 
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
37namespace android {
38using std::vector;
39static const size_t kExponentialFactor = 2;
40bool 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
71typedef enum { ONE = 10, TWO} TestEnum;
72
73template<typename T> struct A { };
74struct B { };
75
76bool 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
114bool 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
183bool 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
218bool 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
258bool 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
277bool 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
300bool 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
341int 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