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 #ifdef GTEST
20 #include "chre/platform/linux/expect_assert.h"
21 #endif
22
23 #include "chre/platform/assert.h"
24 #include "chre/util/dynamic_vector.h"
25 #include "chre/util/macros.h"
26
27 #include <stdint.h>
28
29 using chre::DynamicVector;
30
31 namespace {
32 constexpr int kMaxTestCapacity = 10;
33 int gDestructorCount[kMaxTestCapacity];
34
35 class DestructorCounter {
36 public:
~DestructorCounter()37 ~DestructorCounter() {
38 if (mValue >= 0) {
39 gDestructorCount[mValue]++;
40 }
41 }
42
setValue(int value)43 void setValue(int value) {
44 mValue = value;
45 }
getValue()46 int getValue() {
47 return mValue;
48 }
49
50 private:
51 int mValue = -1;
52 };
53
resetDestructorCounts()54 void resetDestructorCounts() {
55 for (size_t i = 0; i < ARRAY_SIZE(gDestructorCount); i++) {
56 gDestructorCount[i] = 0;
57 }
58 }
59 } // namespace
60
TEST(DynamicVector,EmptyByDefault)61 TEST(DynamicVector, EmptyByDefault) {
62 DynamicVector<int> vector;
63 EXPECT_EQ(vector.data(), nullptr);
64 EXPECT_TRUE(vector.empty());
65 EXPECT_EQ(vector.size(), 0);
66 EXPECT_EQ(vector.capacity(), 0);
67 vector.clear();
68 }
69
TEST(DynamicVector,PushBackAndRead)70 TEST(DynamicVector, PushBackAndRead) {
71 DynamicVector<int> vector;
72 ASSERT_TRUE(vector.push_back(0x1337));
73 EXPECT_EQ(vector.size(), 1);
74 EXPECT_EQ(vector.capacity(), 1);
75 EXPECT_EQ(vector.data(), &vector[0]);
76 EXPECT_FALSE(vector.empty());
77 EXPECT_EQ(vector[0], 0x1337);
78 }
79
TEST(DynamicVector,PushBackReserveAndReadTrivialType)80 TEST(DynamicVector, PushBackReserveAndReadTrivialType) {
81 DynamicVector<int> vector;
82 ASSERT_TRUE(vector.emplace_back(0x1337));
83 ASSERT_TRUE(vector.push_back(0xface));
84 int x = 0xcafe;
85 ASSERT_TRUE(vector.push_back(std::move(x)));
86 ASSERT_TRUE(vector.insert(vector.size(), 0xd00d));
87 EXPECT_EQ(vector.size(), 4);
88 EXPECT_EQ(vector.capacity(), 4);
89 EXPECT_EQ(vector[0], 0x1337);
90 EXPECT_EQ(vector[1], 0xface);
91 EXPECT_EQ(vector[2], 0xcafe);
92 EXPECT_EQ(vector[3], 0xd00d);
93
94 ASSERT_TRUE(vector.reserve(8));
95 EXPECT_EQ(vector.size(), 4);
96 EXPECT_EQ(vector.capacity(), 8);
97 EXPECT_EQ(vector[0], 0x1337);
98 EXPECT_EQ(vector[1], 0xface);
99 EXPECT_EQ(vector[2], 0xcafe);
100 EXPECT_EQ(vector[3], 0xd00d);
101 }
102
TEST(DynamicVector,CompareEqual)103 TEST(DynamicVector, CompareEqual) {
104 DynamicVector<int> lhs;
105 ASSERT_TRUE(lhs.push_back(0x1337));
106 ASSERT_TRUE(lhs.push_back(0xface));
107 DynamicVector<int> rhs;
108 ASSERT_TRUE(rhs.push_back(0x1337));
109 ASSERT_TRUE(rhs.push_back(0xface));
110
111 ASSERT_EQ(lhs, rhs); // equal vectors
112
113 ASSERT_TRUE(lhs.push_back(0xb00c));
114 ASSERT_FALSE(lhs == rhs); // different size
115
116 ASSERT_TRUE(rhs.push_back(0xc00b));
117 ASSERT_FALSE(lhs == rhs); // equal size different elements
118 }
119
120 constexpr int kConstructedMagic = 0xdeadbeef;
121
122 class MovableButNonCopyable : public chre::NonCopyable {
123 public:
MovableButNonCopyable(int value)124 MovableButNonCopyable(int value) : mValue(value) {}
125
MovableButNonCopyable(MovableButNonCopyable && other)126 MovableButNonCopyable(MovableButNonCopyable &&other) {
127 mValue = other.mValue;
128 other.mValue = -1;
129 }
130
operator =(MovableButNonCopyable && other)131 MovableButNonCopyable &operator=(MovableButNonCopyable &&other) {
132 CHRE_ASSERT(mMagic == kConstructedMagic);
133 mValue = other.mValue;
134 other.mValue = -1;
135 return *this;
136 }
137
getValue() const138 int getValue() const {
139 return mValue;
140 }
141
142 private:
143 int mMagic = kConstructedMagic;
144 int mValue;
145 };
146
TEST(DynamicVector,PushBackReserveAndReadMovableButNonCopyable)147 TEST(DynamicVector, PushBackReserveAndReadMovableButNonCopyable) {
148 DynamicVector<MovableButNonCopyable> vector;
149 ASSERT_TRUE(vector.emplace_back(0x1337));
150 ASSERT_TRUE(vector.emplace_back(0xface));
151 MovableButNonCopyable mbnc(0xcafe);
152 ASSERT_TRUE(vector.push_back(std::move(mbnc)));
153 EXPECT_EQ(mbnc.getValue(), -1);
154 MovableButNonCopyable mbnc2(0xd00d);
155 ASSERT_TRUE(vector.insert(vector.size(), std::move(mbnc2)));
156 EXPECT_EQ(mbnc2.getValue(), -1);
157
158 ASSERT_TRUE(vector.reserve(8));
159 EXPECT_EQ(vector[0].getValue(), 0x1337);
160 EXPECT_EQ(vector[1].getValue(), 0xface);
161 EXPECT_EQ(vector[2].getValue(), 0xcafe);
162 EXPECT_EQ(vector[3].getValue(), 0xd00d);
163 EXPECT_EQ(vector.size(), 4);
164 EXPECT_EQ(vector.capacity(), 8);
165 }
166
167 class CopyableButNonMovable {
168 public:
CopyableButNonMovable(int value)169 CopyableButNonMovable(int value) : mValue(value) {}
170
CopyableButNonMovable(const CopyableButNonMovable & other)171 CopyableButNonMovable(const CopyableButNonMovable &other) {
172 mValue = other.mValue;
173 }
174
operator =(const CopyableButNonMovable & other)175 CopyableButNonMovable &operator=(const CopyableButNonMovable &other) {
176 CHRE_ASSERT(mMagic == kConstructedMagic);
177 mValue = other.mValue;
178 return *this;
179 }
180
181 CopyableButNonMovable(CopyableButNonMovable &&other) = delete;
182 CopyableButNonMovable &operator=(CopyableButNonMovable &&other) = delete;
183
getValue() const184 int getValue() const {
185 return mValue;
186 }
187
188 private:
189 int mMagic = kConstructedMagic;
190 int mValue;
191 };
192
TEST(DynamicVector,PushBackReserveAndReadCopyableButNonMovable)193 TEST(DynamicVector, PushBackReserveAndReadCopyableButNonMovable) {
194 DynamicVector<CopyableButNonMovable> vector;
195 ASSERT_TRUE(vector.emplace_back(0x1337));
196 ASSERT_TRUE(vector.emplace_back(0xface));
197 CopyableButNonMovable cbnm(0xcafe);
198 ASSERT_TRUE(vector.push_back(cbnm));
199 CopyableButNonMovable cbnm2(0xd00d);
200 ASSERT_TRUE(vector.insert(vector.size(), cbnm2));
201
202 ASSERT_TRUE(vector.reserve(8));
203 EXPECT_EQ(vector[0].getValue(), 0x1337);
204 EXPECT_EQ(vector[1].getValue(), 0xface);
205 EXPECT_EQ(vector[2].getValue(), 0xcafe);
206 EXPECT_EQ(vector[3].getValue(), 0xd00d);
207 EXPECT_EQ(vector.size(), 4);
208 EXPECT_EQ(vector.capacity(), 8);
209 }
210
211 class MovableAndCopyable {
212 public:
MovableAndCopyable(int value)213 MovableAndCopyable(int value) : mValue(value) {}
214
MovableAndCopyable(const MovableAndCopyable & other)215 MovableAndCopyable(const MovableAndCopyable &other) {
216 mValue = other.mValue;
217 }
218
MovableAndCopyable(MovableAndCopyable && other)219 MovableAndCopyable(MovableAndCopyable &&other) {
220 // The move constructor multiplies the value by 2 so that we can see that it
221 // was used
222 mValue = other.mValue * 2;
223 }
224
operator =(const MovableAndCopyable & other)225 MovableAndCopyable &operator=(const MovableAndCopyable &other) {
226 CHRE_ASSERT(mMagic == kConstructedMagic);
227 mValue = other.mValue;
228 return *this;
229 }
230
operator =(MovableAndCopyable && other)231 MovableAndCopyable &operator=(MovableAndCopyable &&other) {
232 assert(mMagic == kConstructedMagic);
233 mValue = other.mValue * 2;
234 other.mValue = -1;
235 return *this;
236 }
237
getValue() const238 int getValue() const {
239 return mValue;
240 }
241
242 private:
243 int mMagic = kConstructedMagic;
244 int mValue;
245 };
246
TEST(DynamicVector,ReservePrefersMove)247 TEST(DynamicVector, ReservePrefersMove) {
248 // Ensure that preference is given to std::move in reserve()
249 DynamicVector<MovableAndCopyable> vector;
250
251 // Reserve enough space for the first two elements.
252 ASSERT_TRUE(vector.reserve(2));
253 ASSERT_TRUE(vector.emplace_back(1000));
254 ASSERT_TRUE(vector.emplace_back(2000));
255
256 // Reserve more than enough space causing a move to be required.
257 ASSERT_TRUE(vector.reserve(4));
258
259 // Move on this type results in a multiplication by 2. Verify that all
260 // elements have been multiplied by 2.
261 EXPECT_EQ(vector[0].getValue(), 2000);
262 EXPECT_EQ(vector[1].getValue(), 4000);
263 }
264
265 /**
266 * A simple test helper object to count number of construction and destructions.
267 */
268 class Foo {
269 public:
270 /**
271 * Construct an object storing a simple integer. Increment the number of
272 * objects that have been constructed of this type.
273 */
Foo(int value)274 Foo(int value) : value(value) {
275 sConstructedCounter++;
276 }
277
Foo(const Foo & other)278 Foo(const Foo &other) {
279 value = other.value;
280 sConstructedCounter++;
281 }
282
283 Foo(Foo &&other) = delete;
284
285 /**
286 * Tear down the object, decrementing the number of objects that have been
287 * constructed of this type.
288 */
~Foo()289 ~Foo() {
290 sConstructedCounter--;
291 }
292
293 //! The number of objects of this type that have been constructed.
294 static ssize_t sConstructedCounter;
295
296 //! The value stored in the object to verify the contents of this object after
297 //! construction.
298 int value;
299 };
300
301 //! Storage for the Foo reference counter.
302 ssize_t Foo::sConstructedCounter = 0;
303
TEST(DynamicVector,EmplaceBackAndDestruct)304 TEST(DynamicVector, EmplaceBackAndDestruct) {
305 Foo::sConstructedCounter = 0;
306 {
307 DynamicVector<Foo> vector;
308 ASSERT_TRUE(vector.emplace_back(1000));
309 ASSERT_TRUE(vector.emplace_back(2000));
310 ASSERT_TRUE(vector.emplace_back(3000));
311 ASSERT_TRUE(vector.emplace_back(4000));
312
313 ASSERT_EQ(vector[0].value, 1000);
314 ASSERT_EQ(vector[1].value, 2000);
315 ASSERT_EQ(vector[2].value, 3000);
316 ASSERT_EQ(vector[3].value, 4000);
317
318 EXPECT_EQ(Foo::sConstructedCounter, 4);
319 }
320
321 EXPECT_EQ(Foo::sConstructedCounter, 0);
322 }
323
TEST(DynamicVector,InsertEmpty)324 TEST(DynamicVector, InsertEmpty) {
325 DynamicVector<int> vector;
326 EXPECT_CHRE_ASSERT(EXPECT_FALSE(vector.insert(1, 0x1337)));
327
328 // Insert to empty vector
329 ASSERT_TRUE(vector.insert(0, 0x1337));
330 EXPECT_EQ(vector[0], 0x1337);
331
332 // Insert at end triggering grow
333 ASSERT_EQ(vector.capacity(), 1);
334 EXPECT_TRUE(vector.insert(1, 0xface));
335 EXPECT_EQ(vector[0], 0x1337);
336 EXPECT_EQ(vector[1], 0xface);
337
338 // Insert at beginning triggering grow
339 ASSERT_EQ(vector.capacity(), 2);
340 EXPECT_TRUE(vector.insert(0, 0xcafe));
341 EXPECT_EQ(vector[0], 0xcafe);
342 EXPECT_EQ(vector[1], 0x1337);
343 EXPECT_EQ(vector[2], 0xface);
344
345 // Insert at middle with spare capacity
346 ASSERT_EQ(vector.capacity(), 4);
347 EXPECT_TRUE(vector.insert(1, 0xdead));
348 EXPECT_EQ(vector[0], 0xcafe);
349 EXPECT_EQ(vector[1], 0xdead);
350 EXPECT_EQ(vector[2], 0x1337);
351 EXPECT_EQ(vector[3], 0xface);
352
353 // Insert at middle triggering grow
354 ASSERT_EQ(vector.capacity(), 4);
355 EXPECT_TRUE(vector.insert(2, 0xbeef));
356 EXPECT_EQ(vector[0], 0xcafe);
357 EXPECT_EQ(vector[1], 0xdead);
358 EXPECT_EQ(vector[2], 0xbeef);
359 EXPECT_EQ(vector[3], 0x1337);
360 EXPECT_EQ(vector[4], 0xface);
361
362 // Insert at beginning with spare capacity
363 ASSERT_EQ(vector.capacity(), 8);
364 ASSERT_EQ(vector.size(), 5);
365 EXPECT_TRUE(vector.insert(0, 0xabad));
366 EXPECT_EQ(vector[0], 0xabad);
367 EXPECT_EQ(vector[1], 0xcafe);
368 EXPECT_EQ(vector[2], 0xdead);
369 EXPECT_EQ(vector[3], 0xbeef);
370 EXPECT_EQ(vector[4], 0x1337);
371 EXPECT_EQ(vector[5], 0xface);
372
373 // Insert at end with spare capacity
374 ASSERT_EQ(vector.size(), 6);
375 EXPECT_TRUE(vector.insert(vector.size(), 0xc0de));
376 EXPECT_EQ(vector[0], 0xabad);
377 EXPECT_EQ(vector[1], 0xcafe);
378 EXPECT_EQ(vector[2], 0xdead);
379 EXPECT_EQ(vector[3], 0xbeef);
380 EXPECT_EQ(vector[4], 0x1337);
381 EXPECT_EQ(vector[5], 0xface);
382 EXPECT_EQ(vector[6], 0xc0de);
383 }
384
TEST(DynamicVector,PushBackInsertInMiddleAndRead)385 TEST(DynamicVector, PushBackInsertInMiddleAndRead) {
386 DynamicVector<int> vector;
387 ASSERT_TRUE(vector.push_back(0x1337));
388 ASSERT_TRUE(vector.push_back(0xface));
389 ASSERT_TRUE(vector.push_back(0xcafe));
390 ASSERT_TRUE(vector.insert(1, 0xbeef));
391
392 ASSERT_EQ(vector[0], 0x1337);
393 ASSERT_EQ(vector[1], 0xbeef);
394 ASSERT_EQ(vector[2], 0xface);
395 ASSERT_EQ(vector[3], 0xcafe);
396 }
397
TEST(DynamicVector,PushBackAndErase)398 TEST(DynamicVector, PushBackAndErase) {
399 DynamicVector<int> vector;
400 ASSERT_TRUE(vector.push_back(0x1337));
401 ASSERT_TRUE(vector.push_back(0xcafe));
402 ASSERT_TRUE(vector.push_back(0xbeef));
403 ASSERT_TRUE(vector.push_back(0xface));
404
405 vector.erase(1);
406
407 ASSERT_EQ(vector[0], 0x1337);
408 ASSERT_EQ(vector[1], 0xbeef);
409 ASSERT_EQ(vector[2], 0xface);
410 ASSERT_EQ(vector.size(), 3);
411 }
412
TEST(DynamicVector,FindEmpty)413 TEST(DynamicVector, FindEmpty) {
414 DynamicVector<int> vector;
415 ASSERT_EQ(vector.find(0), 0);
416 }
417
TEST(DynamicVector,FindWithElements)418 TEST(DynamicVector, FindWithElements) {
419 DynamicVector<int> vector;
420 ASSERT_TRUE(vector.push_back(0x1337));
421 ASSERT_TRUE(vector.push_back(0xcafe));
422 ASSERT_TRUE(vector.push_back(0xbeef));
423
424 ASSERT_EQ(vector.find(0x1337), 0);
425 ASSERT_EQ(vector.find(0xcafe), 1);
426 ASSERT_EQ(vector.find(0xbeef), 2);
427 ASSERT_EQ(vector.find(1000), 3);
428 }
429
TEST(DynamicVector,EraseDestructorCalled)430 TEST(DynamicVector, EraseDestructorCalled) {
431 resetDestructorCounts();
432
433 DynamicVector<DestructorCounter> vector;
434 vector.reserve(4);
435 for (size_t i = 0; i < 4; ++i) {
436 vector.emplace_back();
437 vector[i].setValue(i);
438 }
439
440 // last item before erase is '3'.
441 vector.erase(1);
442 EXPECT_EQ(0, gDestructorCount[0]);
443 EXPECT_EQ(0, gDestructorCount[1]);
444 EXPECT_EQ(0, gDestructorCount[2]);
445 EXPECT_EQ(1, gDestructorCount[3]);
446
447 // last item before erase is still '3'.
448 vector.erase(2);
449 EXPECT_EQ(0, gDestructorCount[0]);
450 EXPECT_EQ(0, gDestructorCount[1]);
451 EXPECT_EQ(0, gDestructorCount[2]);
452 EXPECT_EQ(2, gDestructorCount[3]);
453
454 // last item before erase is now '2'.
455 vector.erase(0);
456 EXPECT_EQ(0, gDestructorCount[0]);
457 EXPECT_EQ(0, gDestructorCount[1]);
458 EXPECT_EQ(1, gDestructorCount[2]);
459 EXPECT_EQ(2, gDestructorCount[3]);
460 }
461
TEST(DynamicVector,Clear)462 TEST(DynamicVector, Clear) {
463 resetDestructorCounts();
464
465 DynamicVector<DestructorCounter> vector;
466 vector.reserve(4);
467 for (size_t i = 0; i < 4; ++i) {
468 vector.emplace_back();
469 vector[i].setValue(i);
470 }
471
472 vector.clear();
473 EXPECT_EQ(vector.size(), 0);
474 EXPECT_EQ(vector.capacity(), 4);
475
476 for (size_t i = 0; i < 4; ++i) {
477 EXPECT_EQ(gDestructorCount[i], 1);
478 }
479 }
480
TEST(DynamicVectorDeathTest,SwapWithInvalidIndex)481 TEST(DynamicVectorDeathTest, SwapWithInvalidIndex) {
482 DynamicVector<int> vector;
483 vector.push_back(0x1337);
484 vector.push_back(0xcafe);
485 EXPECT_DEATH(vector.swap(0, 2), "");
486 }
487
TEST(DynamicVectorDeathTest,SwapWithInvalidIndices)488 TEST(DynamicVectorDeathTest, SwapWithInvalidIndices) {
489 DynamicVector<int> vector;
490 vector.push_back(0x1337);
491 vector.push_back(0xcafe);
492 EXPECT_DEATH(vector.swap(2, 3), "");
493 }
494
TEST(DynamicVector,Swap)495 TEST(DynamicVector, Swap) {
496 DynamicVector<int> vector;
497 vector.push_back(0x1337);
498 vector.push_back(0xcafe);
499
500 vector.swap(0, 1);
501 EXPECT_EQ(vector[0], 0xcafe);
502 EXPECT_EQ(vector[1], 0x1337);
503 }
504
TEST(DynamicVector,BackFront)505 TEST(DynamicVector, BackFront) {
506 DynamicVector<int> vector;
507 vector.push_back(0x1337);
508 EXPECT_EQ(vector.front(), 0x1337);
509 EXPECT_EQ(vector.back(), 0x1337);
510 vector.push_back(0xcafe);
511 EXPECT_EQ(vector.front(), 0x1337);
512 EXPECT_EQ(vector.back(), 0xcafe);
513 vector.erase(0);
514 EXPECT_EQ(vector.front(), 0xcafe);
515 EXPECT_EQ(vector.back(), 0xcafe);
516 }
517
TEST(DynamicVector,Iterator)518 TEST(DynamicVector, Iterator) {
519 DynamicVector<int> vector;
520 vector.push_back(0);
521 vector.push_back(1);
522 vector.push_back(2);
523
524 size_t index = 0;
525 for (DynamicVector<int>::iterator it = vector.begin(); it != vector.end();
526 ++it) {
527 EXPECT_EQ(vector[index++], *it);
528 }
529
530 DynamicVector<int>::iterator it = vector.begin() + vector.size() - 1;
531 EXPECT_EQ(vector[vector.size() - 1], *it);
532
533 it = vector.begin() + vector.size();
534 EXPECT_TRUE(it == vector.end());
535 }
536
TEST(DynamicVector,ConstIterator)537 TEST(DynamicVector, ConstIterator) {
538 DynamicVector<int> vector;
539 vector.push_back(0);
540 vector.push_back(1);
541 vector.push_back(2);
542
543 size_t index = 0;
544 for (DynamicVector<int>::const_iterator cit = vector.cbegin();
545 cit != vector.cend(); ++cit) {
546 EXPECT_EQ(vector[index++], *cit);
547 }
548
549 DynamicVector<int>::const_iterator cit = vector.cbegin() + vector.size() - 1;
550 EXPECT_EQ(vector[vector.size() - 1], *cit);
551
552 cit = vector.cbegin() + vector.size();
553 EXPECT_TRUE(cit == vector.cend());
554 }
555
TEST(DynamicVector,IteratorAndPushBack)556 TEST(DynamicVector, IteratorAndPushBack) {
557 DynamicVector<int> vector;
558 vector.push_back(0);
559 vector.push_back(1);
560 vector.push_back(2);
561 size_t oldCapacity = vector.capacity();
562
563 DynamicVector<int>::iterator it_b = vector.begin();
564 DynamicVector<int>::iterator it_e = vector.end();
565
566 vector.push_back(3);
567 ASSERT_TRUE(oldCapacity == vector.capacity());
568
569 size_t index = 0;
570 for (; it_b != it_e; ++it_b) {
571 EXPECT_EQ(vector[index++], *it_b);
572 }
573 }
574
TEST(DynamicVector,IteratorAndEmplaceBack)575 TEST(DynamicVector, IteratorAndEmplaceBack) {
576 DynamicVector<int> vector;
577 vector.push_back(0);
578 vector.push_back(1);
579 vector.push_back(2);
580 size_t oldCapacity = vector.capacity();
581
582 DynamicVector<int>::iterator it_b = vector.begin();
583 DynamicVector<int>::iterator it_e = vector.end();
584
585 vector.emplace_back(3);
586 ASSERT_TRUE(oldCapacity == vector.capacity());
587
588 size_t index = 0;
589 for (; it_b != it_e; ++it_b) {
590 EXPECT_EQ(vector[index++], *it_b);
591 }
592 }
593
TEST(DynamicVector,IteratorAndReserve)594 TEST(DynamicVector, IteratorAndReserve) {
595 DynamicVector<int> vector;
596 vector.push_back(0);
597 vector.push_back(1);
598 vector.push_back(2);
599 size_t oldCapacity = vector.capacity();
600
601 DynamicVector<int>::iterator it_b = vector.begin();
602 DynamicVector<int>::iterator it_e = vector.end();
603
604 vector.reserve(oldCapacity);
605 ASSERT_TRUE(oldCapacity == vector.capacity());
606
607 size_t index = 0;
608 for (; it_b != it_e; ++it_b) {
609 EXPECT_EQ(vector[index++], *it_b);
610 }
611 }
612
TEST(DynamicVector,IteratorAndInsert)613 TEST(DynamicVector, IteratorAndInsert) {
614 DynamicVector<int> vector;
615 vector.push_back(0);
616 vector.push_back(1);
617 vector.push_back(2);
618 size_t oldCapacity = vector.capacity();
619
620 DynamicVector<int>::iterator it_b = vector.begin();
621
622 vector.insert(2, 3);
623 ASSERT_TRUE(oldCapacity == vector.capacity());
624
625 size_t index = 0;
626 while (index < 2) {
627 EXPECT_EQ(vector[index++], *it_b++);
628 }
629 }
630
TEST(DynamicVector,IteratorAndErase)631 TEST(DynamicVector, IteratorAndErase) {
632 DynamicVector<int> vector;
633 vector.push_back(0);
634 vector.push_back(1);
635 vector.push_back(2);
636
637 DynamicVector<int>::iterator it_b = vector.begin();
638
639 vector.erase(2);
640
641 size_t index = 0;
642 while (index < 2) {
643 EXPECT_EQ(vector[index++], *it_b++);
644 }
645 }
646
TEST(DynamicVector,IteratorAndSwap)647 TEST(DynamicVector, IteratorAndSwap) {
648 DynamicVector<int> vector;
649 vector.push_back(0);
650 vector.push_back(1);
651 vector.push_back(2);
652 vector.push_back(3);
653
654 DynamicVector<int>::iterator it_b = vector.begin();
655
656 vector.swap(1, 3);
657
658 size_t index = 0;
659 while (index < 4) {
660 if (index != 1 && index != 3) {
661 EXPECT_EQ(vector[index], *it_b);
662 }
663 index++;
664 it_b++;
665 }
666 }
667
TEST(DynamicVector,MoveConstruct)668 TEST(DynamicVector, MoveConstruct) {
669 DynamicVector<int> vector;
670 ASSERT_TRUE(vector.push_back(0));
671 ASSERT_TRUE(vector.push_back(1));
672 ASSERT_TRUE(vector.push_back(2));
673
674 DynamicVector<int> movedVector(std::move(vector));
675 EXPECT_EQ(vector.data(), nullptr);
676 EXPECT_NE(movedVector.data(), nullptr);
677 EXPECT_EQ(vector.size(), 0);
678 EXPECT_EQ(movedVector.size(), 3);
679 EXPECT_EQ(vector.capacity(), 0);
680 EXPECT_EQ(movedVector.capacity(), 4);
681 }
682
TEST(DynamicVector,MoveAssignmentConstruct)683 TEST(DynamicVector, MoveAssignmentConstruct) {
684 DynamicVector<int> vector;
685 ASSERT_TRUE(vector.push_back(0));
686 ASSERT_TRUE(vector.push_back(1));
687 ASSERT_TRUE(vector.push_back(2));
688
689 DynamicVector<int> movedVector;
690 movedVector = std::move(vector);
691 EXPECT_EQ(vector.data(), nullptr);
692 EXPECT_NE(movedVector.data(), nullptr);
693 EXPECT_EQ(vector.size(), 0);
694 EXPECT_EQ(movedVector.size(), 3);
695 EXPECT_EQ(vector.capacity(), 0);
696 EXPECT_EQ(movedVector.capacity(), 4);
697 }
698
TEST(DynamicVector,PrepareForPush)699 TEST(DynamicVector, PrepareForPush) {
700 DynamicVector<int> vector;
701 EXPECT_EQ(vector.size(), 0);
702 EXPECT_EQ(vector.capacity(), 0);
703
704 // Perform an initial prepareForPush operation which causes a size of one.
705 ASSERT_TRUE(vector.prepareForPush());
706 EXPECT_EQ(vector.size(), 0);
707 EXPECT_EQ(vector.capacity(), 1);
708 ASSERT_TRUE(vector.push_back(0xcafe));
709 EXPECT_EQ(vector.size(), 1);
710 EXPECT_EQ(vector.capacity(), 1);
711
712 // Verify that it becomes larger
713 ASSERT_TRUE(vector.prepareForPush());
714 EXPECT_EQ(vector[0], 0xcafe);
715 EXPECT_EQ(vector.size(), 1);
716 EXPECT_EQ(vector.capacity(), 2);
717
718 // The vector should not become any larger than necessary.
719 ASSERT_TRUE(vector.prepareForPush());
720 EXPECT_EQ(vector[0], 0xcafe);
721 EXPECT_EQ(vector.size(), 1);
722 EXPECT_EQ(vector.capacity(), 2);
723 }
724
725 // TODO: Add a test for when memory allocation returns nullptr.
726
TEST(DynamicVector,PopBack)727 TEST(DynamicVector, PopBack) {
728 DynamicVector<int> vector;
729 constexpr size_t kSize = 4;
730 for (int i = 0; i < kSize; i++) {
731 vector.push_back(i);
732 }
733
734 for (int i = kSize - 1; i >= 0; i--) {
735 EXPECT_EQ(vector.back(), i);
736 vector.pop_back();
737 }
738 EXPECT_TRUE(vector.empty());
739 }
740
741 /**
742 * A test class to default construct an integer with an incrementing value.
743 */
744 struct FancyInt {
745 static int index;
746 int value;
747
FancyIntFancyInt748 FancyInt() : value(index++) {}
749 };
750
751 int FancyInt::index;
752
TEST(DynamicVector,Resize)753 TEST(DynamicVector, Resize) {
754 FancyInt::index = 0;
755 DynamicVector<FancyInt> vector;
756 ASSERT_TRUE(vector.resize(4));
757 ASSERT_EQ(vector.size(), 4);
758
759 EXPECT_EQ(vector[0].value, 0);
760 EXPECT_EQ(vector[1].value, 1);
761 EXPECT_EQ(vector[2].value, 2);
762 EXPECT_EQ(vector[3].value, 3);
763
764 ASSERT_TRUE(vector.resize(2));
765 ASSERT_EQ(vector.size(), 2);
766
767 EXPECT_EQ(vector[0].value, 0);
768 EXPECT_EQ(vector[1].value, 1);
769
770 ASSERT_TRUE(vector.resize(4));
771 ASSERT_EQ(vector.size(), 4);
772
773 EXPECT_EQ(vector[0].value, 0);
774 EXPECT_EQ(vector[1].value, 1);
775 EXPECT_EQ(vector[2].value, 4);
776 EXPECT_EQ(vector[3].value, 5);
777
778 // Ensure that we don't overshoot the requested size
779 ASSERT_TRUE(vector.resize(99));
780 EXPECT_EQ(vector.size(), 99);
781 EXPECT_EQ(vector.capacity(), 99);
782 }
783
784 /**
785 * A test class that exceeds the default max alignment and is not trivial.
786 */
787 struct alignas(64) ExceedsMaxAlignNotTrivial {
ExceedsMaxAlignNotTrivialExceedsMaxAlignNotTrivial788 ExceedsMaxAlignNotTrivial() {
789 value = 1000;
790 }
791
792 int value;
793 };
794
795 /**
796 * A test class that exceeds the default max alignment and is trivial.
797 */
798 struct alignas(64) ExceedsMaxAlignIsTrivial {
799 int value;
800 };
801
802 static_assert(alignof(ExceedsMaxAlignNotTrivial) > alignof(std::max_align_t));
803 static_assert(!std::is_trivial<ExceedsMaxAlignNotTrivial>::value);
804 static_assert(alignof(ExceedsMaxAlignIsTrivial) > alignof(std::max_align_t));
805 static_assert(std::is_trivial<ExceedsMaxAlignIsTrivial>::value);
806
TEST(DynamicVector,AlignedAllocExceedsMaxAlignNotTrivial)807 TEST(DynamicVector, AlignedAllocExceedsMaxAlignNotTrivial) {
808 for (size_t i = 0; i < 10; ++i) {
809 chre::DynamicVector<ExceedsMaxAlignNotTrivial> vector;
810 for (size_t j = 0; j < i; ++j) {
811 ExceedsMaxAlignNotTrivial exceedsMaxAlignNotTrivial;
812 EXPECT_TRUE(vector.push_back(exceedsMaxAlignNotTrivial));
813 EXPECT_NE(vector.data(), nullptr);
814 EXPECT_EQ(reinterpret_cast<uint64_t>(vector.data()) %
815 alignof(ExceedsMaxAlignNotTrivial),
816 0);
817 }
818 }
819 }
820
TEST(DynamicVector,AlignedAllocExceedsMaxAlignIsTrivial)821 TEST(DynamicVector, AlignedAllocExceedsMaxAlignIsTrivial) {
822 for (size_t i = 0; i < 10; ++i) {
823 chre::DynamicVector<ExceedsMaxAlignIsTrivial> vector;
824 for (size_t j = 0; j < i; ++j) {
825 ExceedsMaxAlignIsTrivial exceedsMaxAlignIsTrivial;
826 EXPECT_TRUE(vector.push_back(exceedsMaxAlignIsTrivial));
827 EXPECT_NE(vector.data(), nullptr);
828 EXPECT_EQ(reinterpret_cast<uint64_t>(vector.data()) %
829 alignof(ExceedsMaxAlignIsTrivial),
830 0);
831 }
832 }
833 }
834