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:
29   ~Foo() {
30     if (mValue >= 0) {
31       destructor_count[mValue]++;
32     }
33   };
34   void setValue(int value) {
35     mValue = value;
36   }
37 
38  private:
39   int mValue = -1;
40 };
41 }  // namespace
42 
43 TEST(FixedSizeVector, EmptyWithCapacityWithDefault) {
44   FixedSizeVector<int, 8> testVector;
45   ASSERT_NE(testVector.data(), nullptr);
46   ASSERT_EQ(testVector.size(), 0);
47   ASSERT_EQ(testVector.capacity(), 8);
48   ASSERT_TRUE(testVector.empty());
49   ASSERT_FALSE(testVector.full());
50 }
51 
52 TEST(FixedSizeVector, PushBackOneAndRead) {
53   FixedSizeVector<int, 8> testVector;
54   testVector.push_back(0x1337);
55   ASSERT_NE(testVector.data(), nullptr);
56   ASSERT_EQ(testVector.size(), 1);
57   ASSERT_EQ(testVector.capacity(), 8);
58   ASSERT_FALSE(testVector.empty());
59   ASSERT_FALSE(testVector.full());
60   ASSERT_EQ(testVector[0], 0x1337);
61 }
62 
63 TEST(FixedSizeVector, PushBackUntilFullAndRead) {
64   FixedSizeVector<int, 4> testVector;
65   testVector.push_back(1000);
66   testVector.push_back(2000);
67   testVector.push_back(3000);
68   testVector.push_back(4000);
69 
70   ASSERT_NE(testVector.data(), nullptr);
71   ASSERT_TRUE(testVector.full());
72   ASSERT_FALSE(testVector.empty());
73   ASSERT_EQ(testVector.size(), 4);
74   ASSERT_EQ(testVector[0], 1000);
75   ASSERT_EQ(testVector[1], 2000);
76   ASSERT_EQ(testVector[2], 3000);
77   ASSERT_EQ(testVector[3], 4000);
78 
79   ASSERT_EQ(testVector.data()[0], 1000);
80   ASSERT_EQ(testVector.data()[1], 2000);
81   ASSERT_EQ(testVector.data()[2], 3000);
82   ASSERT_EQ(testVector.data()[3], 4000);
83 }
84 
85 TEST(FixedSizeVector, PushBackAndErase) {
86   FixedSizeVector<int, 8> vector;
87   vector.push_back(0x1337);
88   vector.push_back(0xcafe);
89   vector.push_back(0xbeef);
90   vector.push_back(0xface);
91 
92   vector.erase(1);
93   ASSERT_EQ(vector[0], 0x1337);
94   ASSERT_EQ(vector.data()[0], 0x1337);
95   ASSERT_EQ(vector[1], 0xbeef);
96   ASSERT_EQ(vector.data()[1], 0xbeef);
97   ASSERT_EQ(vector[2], 0xface);
98   ASSERT_EQ(vector.data()[2], 0xface);
99   ASSERT_EQ(vector.size(), 3);
100 }
101 
102 TEST(FixedSizeVector, PushBackAndPopBack) {
103   FixedSizeVector<int, 8> vector;
104   vector.push_back(0x1337);
105   vector.push_back(0xcafe);
106   vector.push_back(0xbeef);
107   vector.push_back(0xface);
108 
109   ASSERT_EQ(vector.size(), 4);
110   ASSERT_EQ(vector.back(), 0xface);
111   vector.pop_back();
112   ASSERT_EQ(vector.size(), 3);
113   ASSERT_EQ(vector.back(), 0xbeef);
114   vector.pop_back();
115   ASSERT_EQ(vector.size(), 2);
116   ASSERT_EQ(vector.back(), 0xcafe);
117   vector.pop_back();
118   ASSERT_EQ(vector.size(), 1);
119   ASSERT_EQ(vector.back(), 0x1337);
120   vector.pop_back();
121   ASSERT_EQ(vector.size(), 0);
122 }
123 
124 TEST(FixedSizeVector, EraseDestructorCalled) {
125   FixedSizeVector<Foo, 4> vector;
126   for (size_t i = 0; i < 4; ++i) {
127     vector.push_back(Foo());
128     vector[i].setValue(i);
129   }
130 
131   // last item before erase is '3'.
132   vector.erase(1);
133   EXPECT_EQ(0, destructor_count[0]);
134   EXPECT_EQ(0, destructor_count[1]);
135   EXPECT_EQ(0, destructor_count[2]);
136   EXPECT_EQ(1, destructor_count[3]);
137 
138   // last item before erase is still '3'.
139   vector.erase(2);
140   EXPECT_EQ(0, destructor_count[0]);
141   EXPECT_EQ(0, destructor_count[1]);
142   EXPECT_EQ(0, destructor_count[2]);
143   EXPECT_EQ(2, destructor_count[3]);
144 
145   // last item before erase is now '2'.
146   vector.erase(0);
147   EXPECT_EQ(0, destructor_count[0]);
148   EXPECT_EQ(0, destructor_count[1]);
149   EXPECT_EQ(1, destructor_count[2]);
150   EXPECT_EQ(2, destructor_count[3]);
151 }
152 
153 TEST(FixedSizeVectorDeathTest, SwapWithInvalidIndex) {
154   FixedSizeVector<int, 4> vector;
155   vector.push_back(0x1337);
156   vector.push_back(0xcafe);
157   EXPECT_DEATH(vector.swap(0, 2), "");
158 }
159 
160 TEST(FixedSizeVectorDeathTest, SwapWithInvalidIndices) {
161   FixedSizeVector<int, 4> vector;
162   vector.push_back(0x1337);
163   vector.push_back(0xcafe);
164   EXPECT_DEATH(vector.swap(2, 3), "");
165 }
166 
167 TEST(FixedSizeVector, Swap) {
168   FixedSizeVector<int, 4> vector;
169   vector.push_back(0x1337);
170   vector.push_back(0xcafe);
171 
172   vector.swap(0, 1);
173   EXPECT_EQ(vector[0], 0xcafe);
174   EXPECT_EQ(vector[1], 0x1337);
175 }
176 
177 TEST(FixedSizeVector, ResizeLarger) {
178   FixedSizeVector<int, 4> vector;
179   vector.resize(4);
180   EXPECT_EQ(vector.size(), 4);
181 }
182 
183 TEST(FixedSizeVector, ResizeSmaller) {
184   destructor_count[0] = 0;
185 
186   FixedSizeVector<Foo, 4> vector;
187   for (size_t i = 0; i < 3; i++) {
188     vector.push_back(Foo());
189     vector[i].setValue(0);
190   }
191 
192   EXPECT_EQ(vector.size(), 3);
193   EXPECT_EQ(destructor_count[0], 0);
194   vector.resize(2);
195   EXPECT_EQ(vector.size(), 2);
196   EXPECT_EQ(destructor_count[0], 1);
197 }
198 
199 TEST(FixedSizeVector, Iterator) {
200   FixedSizeVector<int, 8> vector;
201   vector.push_back(0);
202   vector.push_back(1);
203   vector.push_back(2);
204 
205   size_t index = 0;
206   for (FixedSizeVector<int, 8>::iterator it = vector.begin();
207        it != vector.end(); ++it) {
208     EXPECT_EQ(vector[index++], *it);
209   }
210 
211   FixedSizeVector<int, 8>::iterator it = vector.begin() + vector.size() - 1;
212   EXPECT_EQ(vector[vector.size() - 1], *it);
213 
214   it = vector.begin() + vector.size();
215   EXPECT_TRUE(it == vector.end());
216 }
217 
218 TEST(FixedSizeVector, ConstIterator) {
219   FixedSizeVector<int, 8> vector;
220   vector.push_back(0);
221   vector.push_back(1);
222   vector.push_back(2);
223 
224   size_t index = 0;
225   for (FixedSizeVector<int, 8>::const_iterator cit = vector.cbegin();
226        cit != vector.cend(); ++cit) {
227     EXPECT_EQ(vector[index++], *cit);
228   }
229 
230   FixedSizeVector<int, 8>::const_iterator cit =
231       vector.cbegin() + vector.size() - 1;
232   EXPECT_EQ(vector[vector.size() - 1], *cit);
233 
234   cit = vector.cbegin() + vector.size();
235   EXPECT_TRUE(cit == vector.cend());
236 }
237 
238 TEST(FixedSizeVector, IteratorAndPushBack) {
239   FixedSizeVector<int, 8> vector;
240   vector.push_back(0);
241   vector.push_back(1);
242   vector.push_back(2);
243 
244   FixedSizeVector<int, 8>::iterator it_b = vector.begin();
245   FixedSizeVector<int, 8>::iterator it_e = vector.end();
246 
247   vector.push_back(3);
248 
249   size_t index = 0;
250   while (it_b != it_e) {
251     EXPECT_EQ(vector[index++], *it_b++);
252   }
253 }
254 
255 TEST(FixedSizeVector, IteratorAndEmplaceBack) {
256   FixedSizeVector<int, 8> vector;
257   vector.push_back(0);
258   vector.push_back(1);
259   vector.push_back(2);
260 
261   FixedSizeVector<int, 8>::iterator it_b = vector.begin();
262   FixedSizeVector<int, 8>::iterator it_e = vector.end();
263 
264   vector.emplace_back(3);
265 
266   size_t index = 0;
267   while (it_b != it_e) {
268     EXPECT_EQ(vector[index++], *it_b++);
269   }
270 }
271 
272 TEST(FixedSizeVector, IteratorAndErase) {
273   FixedSizeVector<int, 8> vector;
274   vector.push_back(0);
275   vector.push_back(1);
276   vector.push_back(2);
277 
278   FixedSizeVector<int, 8>::iterator it_b = vector.begin();
279 
280   vector.erase(2);
281 
282   size_t index = 0;
283   while (index < 2) {
284     EXPECT_EQ(vector[index++], *it_b++);
285   }
286 }
287 
288 TEST(FixedSizeVector, IteratorAndSwap) {
289   FixedSizeVector<int, 8> vector;
290   vector.push_back(0);
291   vector.push_back(1);
292   vector.push_back(2);
293   vector.push_back(3);
294 
295   FixedSizeVector<int, 8>::iterator it_b = vector.begin();
296 
297   vector.swap(1, 3);
298 
299   size_t index = 0;
300   while (index < 4) {
301     if (index != 1 && index != 3) {
302       EXPECT_EQ(vector[index], *it_b);
303     }
304     index++;
305     it_b++;
306   }
307 }
308 
309 TEST(FixedSizeVector, IteratorAndResize) {
310   FixedSizeVector<int, 8> vector;
311   vector.push_back(0);
312   vector.push_back(1);
313   vector.push_back(2);
314   vector.push_back(3);
315 
316   FixedSizeVector<int, 8>::iterator it_b = vector.begin();
317 
318   vector.resize(2);
319 
320   size_t index = 0;
321   while (index < 2) {
322     EXPECT_EQ(vector[index++], *it_b++);
323   }
324 }
325