1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "gtest/gtest.h"
18
19 #include "chre/util/fixed_size_vector.h"
20
21 using chre::FixedSizeVector;
22
23 namespace {
24 constexpr int kMaxTestCapacity = 10;
25 int destructor_count[kMaxTestCapacity];
26
27 class Foo {
28 public:
~Foo()29 ~Foo() {
30 if (mValue >= 0) {
31 destructor_count[mValue]++;
32 }
33 }
34
setValue(int value)35 void setValue(int value) {
36 mValue = value;
37 }
38
39 private:
40 int mValue = -1;
41 };
42 } // namespace
43
TEST(FixedSizeVector,EmptyWithCapacityWithDefault)44 TEST(FixedSizeVector, EmptyWithCapacityWithDefault) {
45 FixedSizeVector<int, 8> testVector;
46 ASSERT_NE(testVector.data(), nullptr);
47 ASSERT_EQ(testVector.size(), 0);
48 ASSERT_EQ(testVector.capacity(), 8);
49 ASSERT_TRUE(testVector.empty());
50 ASSERT_FALSE(testVector.full());
51 }
52
TEST(FixedSizeVector,PushBackOneAndRead)53 TEST(FixedSizeVector, PushBackOneAndRead) {
54 FixedSizeVector<int, 8> testVector;
55 testVector.push_back(0x1337);
56 ASSERT_NE(testVector.data(), nullptr);
57 ASSERT_EQ(testVector.size(), 1);
58 ASSERT_EQ(testVector.capacity(), 8);
59 ASSERT_FALSE(testVector.empty());
60 ASSERT_FALSE(testVector.full());
61 ASSERT_EQ(testVector[0], 0x1337);
62 }
63
TEST(FixedSizeVector,PushBackUntilFullAndRead)64 TEST(FixedSizeVector, PushBackUntilFullAndRead) {
65 FixedSizeVector<int, 4> testVector;
66 testVector.push_back(1000);
67 testVector.push_back(2000);
68 testVector.push_back(3000);
69 testVector.push_back(4000);
70
71 ASSERT_NE(testVector.data(), nullptr);
72 ASSERT_TRUE(testVector.full());
73 ASSERT_FALSE(testVector.empty());
74 ASSERT_EQ(testVector.size(), 4);
75 ASSERT_EQ(testVector[0], 1000);
76 ASSERT_EQ(testVector[1], 2000);
77 ASSERT_EQ(testVector[2], 3000);
78 ASSERT_EQ(testVector[3], 4000);
79
80 ASSERT_EQ(testVector.data()[0], 1000);
81 ASSERT_EQ(testVector.data()[1], 2000);
82 ASSERT_EQ(testVector.data()[2], 3000);
83 ASSERT_EQ(testVector.data()[3], 4000);
84 }
85
TEST(FixedSizeVector,PushBackAndErase)86 TEST(FixedSizeVector, PushBackAndErase) {
87 FixedSizeVector<int, 8> vector;
88 vector.push_back(0x1337);
89 vector.push_back(0xcafe);
90 vector.push_back(0xbeef);
91 vector.push_back(0xface);
92
93 vector.erase(1);
94 ASSERT_EQ(vector[0], 0x1337);
95 ASSERT_EQ(vector.data()[0], 0x1337);
96 ASSERT_EQ(vector[1], 0xbeef);
97 ASSERT_EQ(vector.data()[1], 0xbeef);
98 ASSERT_EQ(vector[2], 0xface);
99 ASSERT_EQ(vector.data()[2], 0xface);
100 ASSERT_EQ(vector.size(), 3);
101 }
102
TEST(FixedSizeVector,PushBackAndPopBack)103 TEST(FixedSizeVector, PushBackAndPopBack) {
104 FixedSizeVector<int, 8> vector;
105 vector.push_back(0x1337);
106 vector.push_back(0xcafe);
107 vector.push_back(0xbeef);
108 vector.push_back(0xface);
109
110 ASSERT_EQ(vector.size(), 4);
111 ASSERT_EQ(vector.back(), 0xface);
112 vector.pop_back();
113 ASSERT_EQ(vector.size(), 3);
114 ASSERT_EQ(vector.back(), 0xbeef);
115 vector.pop_back();
116 ASSERT_EQ(vector.size(), 2);
117 ASSERT_EQ(vector.back(), 0xcafe);
118 vector.pop_back();
119 ASSERT_EQ(vector.size(), 1);
120 ASSERT_EQ(vector.back(), 0x1337);
121 vector.pop_back();
122 ASSERT_EQ(vector.size(), 0);
123 }
124
TEST(FixedSizeVector,EraseDestructorCalled)125 TEST(FixedSizeVector, EraseDestructorCalled) {
126 FixedSizeVector<Foo, 4> vector;
127 for (size_t i = 0; i < 4; ++i) {
128 vector.push_back(Foo());
129 vector[i].setValue(i);
130 }
131
132 // last item before erase is '3'.
133 vector.erase(1);
134 EXPECT_EQ(0, destructor_count[0]);
135 EXPECT_EQ(0, destructor_count[1]);
136 EXPECT_EQ(0, destructor_count[2]);
137 EXPECT_EQ(1, destructor_count[3]);
138
139 // last item before erase is still '3'.
140 vector.erase(2);
141 EXPECT_EQ(0, destructor_count[0]);
142 EXPECT_EQ(0, destructor_count[1]);
143 EXPECT_EQ(0, destructor_count[2]);
144 EXPECT_EQ(2, destructor_count[3]);
145
146 // last item before erase is now '2'.
147 vector.erase(0);
148 EXPECT_EQ(0, destructor_count[0]);
149 EXPECT_EQ(0, destructor_count[1]);
150 EXPECT_EQ(1, destructor_count[2]);
151 EXPECT_EQ(2, destructor_count[3]);
152 }
153
TEST(FixedSizeVectorDeathTest,SwapWithInvalidIndex)154 TEST(FixedSizeVectorDeathTest, SwapWithInvalidIndex) {
155 FixedSizeVector<int, 4> vector;
156 vector.push_back(0x1337);
157 vector.push_back(0xcafe);
158 EXPECT_DEATH(vector.swap(0, 2), "");
159 }
160
TEST(FixedSizeVectorDeathTest,SwapWithInvalidIndices)161 TEST(FixedSizeVectorDeathTest, SwapWithInvalidIndices) {
162 FixedSizeVector<int, 4> vector;
163 vector.push_back(0x1337);
164 vector.push_back(0xcafe);
165 EXPECT_DEATH(vector.swap(2, 3), "");
166 }
167
TEST(FixedSizeVector,Swap)168 TEST(FixedSizeVector, Swap) {
169 FixedSizeVector<int, 4> vector;
170 vector.push_back(0x1337);
171 vector.push_back(0xcafe);
172
173 vector.swap(0, 1);
174 EXPECT_EQ(vector[0], 0xcafe);
175 EXPECT_EQ(vector[1], 0x1337);
176 }
177
TEST(FixedSizeVector,ResizeLarger)178 TEST(FixedSizeVector, ResizeLarger) {
179 FixedSizeVector<int, 4> vector;
180 vector.resize(4);
181 EXPECT_EQ(vector.size(), 4);
182 }
183
TEST(FixedSizeVector,ResizeSmaller)184 TEST(FixedSizeVector, ResizeSmaller) {
185 destructor_count[0] = 0;
186
187 FixedSizeVector<Foo, 4> vector;
188 for (size_t i = 0; i < 3; i++) {
189 vector.push_back(Foo());
190 vector[i].setValue(0);
191 }
192
193 EXPECT_EQ(vector.size(), 3);
194 EXPECT_EQ(destructor_count[0], 0);
195 vector.resize(2);
196 EXPECT_EQ(vector.size(), 2);
197 EXPECT_EQ(destructor_count[0], 1);
198 }
199
TEST(FixedSizeVector,Iterator)200 TEST(FixedSizeVector, Iterator) {
201 FixedSizeVector<int, 8> vector;
202 vector.push_back(0);
203 vector.push_back(1);
204 vector.push_back(2);
205
206 size_t index = 0;
207 for (FixedSizeVector<int, 8>::iterator it = vector.begin();
208 it != vector.end(); ++it) {
209 EXPECT_EQ(vector[index++], *it);
210 }
211
212 FixedSizeVector<int, 8>::iterator it = vector.begin() + vector.size() - 1;
213 EXPECT_EQ(vector[vector.size() - 1], *it);
214
215 it = vector.begin() + vector.size();
216 EXPECT_TRUE(it == vector.end());
217 }
218
TEST(FixedSizeVector,ConstIterator)219 TEST(FixedSizeVector, ConstIterator) {
220 FixedSizeVector<int, 8> vector;
221 vector.push_back(0);
222 vector.push_back(1);
223 vector.push_back(2);
224
225 size_t index = 0;
226 for (FixedSizeVector<int, 8>::const_iterator cit = vector.cbegin();
227 cit != vector.cend(); ++cit) {
228 EXPECT_EQ(vector[index++], *cit);
229 }
230
231 FixedSizeVector<int, 8>::const_iterator cit =
232 vector.cbegin() + vector.size() - 1;
233 EXPECT_EQ(vector[vector.size() - 1], *cit);
234
235 cit = vector.cbegin() + vector.size();
236 EXPECT_TRUE(cit == vector.cend());
237 }
238
TEST(FixedSizeVector,IteratorAndPushBack)239 TEST(FixedSizeVector, IteratorAndPushBack) {
240 FixedSizeVector<int, 8> vector;
241 vector.push_back(0);
242 vector.push_back(1);
243 vector.push_back(2);
244
245 FixedSizeVector<int, 8>::iterator it_b = vector.begin();
246 FixedSizeVector<int, 8>::iterator it_e = vector.end();
247
248 vector.push_back(3);
249
250 size_t index = 0;
251 while (it_b != it_e) {
252 EXPECT_EQ(vector[index++], *it_b++);
253 }
254 }
255
TEST(FixedSizeVector,IteratorAndEmplaceBack)256 TEST(FixedSizeVector, IteratorAndEmplaceBack) {
257 FixedSizeVector<int, 8> vector;
258 vector.push_back(0);
259 vector.push_back(1);
260 vector.push_back(2);
261
262 FixedSizeVector<int, 8>::iterator it_b = vector.begin();
263 FixedSizeVector<int, 8>::iterator it_e = vector.end();
264
265 vector.emplace_back(3);
266
267 size_t index = 0;
268 while (it_b != it_e) {
269 EXPECT_EQ(vector[index++], *it_b++);
270 }
271 }
272
TEST(FixedSizeVector,IteratorAndErase)273 TEST(FixedSizeVector, IteratorAndErase) {
274 FixedSizeVector<int, 8> vector;
275 vector.push_back(0);
276 vector.push_back(1);
277 vector.push_back(2);
278
279 FixedSizeVector<int, 8>::iterator it_b = vector.begin();
280
281 vector.erase(2);
282
283 size_t index = 0;
284 while (index < 2) {
285 EXPECT_EQ(vector[index++], *it_b++);
286 }
287 }
288
TEST(FixedSizeVector,IteratorAndSwap)289 TEST(FixedSizeVector, IteratorAndSwap) {
290 FixedSizeVector<int, 8> vector;
291 vector.push_back(0);
292 vector.push_back(1);
293 vector.push_back(2);
294 vector.push_back(3);
295
296 FixedSizeVector<int, 8>::iterator it_b = vector.begin();
297
298 vector.swap(1, 3);
299
300 size_t index = 0;
301 while (index < 4) {
302 if (index != 1 && index != 3) {
303 EXPECT_EQ(vector[index], *it_b);
304 }
305 index++;
306 it_b++;
307 }
308 }
309
TEST(FixedSizeVector,IteratorAndResize)310 TEST(FixedSizeVector, IteratorAndResize) {
311 FixedSizeVector<int, 8> vector;
312 vector.push_back(0);
313 vector.push_back(1);
314 vector.push_back(2);
315 vector.push_back(3);
316
317 FixedSizeVector<int, 8>::iterator it_b = vector.begin();
318
319 vector.resize(2);
320
321 size_t index = 0;
322 while (index < 2) {
323 EXPECT_EQ(vector[index++], *it_b++);
324 }
325 }
326