dynamic_vector_test.cc revision 12048259ea9203bccb00460b821a40731249f1e2 
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/dynamic_vector.h"
20
21using chre::DynamicVector;
22
23namespace {
24constexpr int kMaxTestCapacity = 10;
25int destructor_count[kMaxTestCapacity];
26
27class Dummy {
28 public:
29  ~Dummy() {
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}
42
43TEST(DynamicVector, EmptyByDefault) {
44  DynamicVector<int> vector;
45  ASSERT_EQ(vector.data(), nullptr);
46  ASSERT_EQ(vector.size(), 0);
47  ASSERT_EQ(vector.capacity(), 0);
48}
49
50TEST(DynamicVector, PushBackAndRead) {
51  DynamicVector<int> vector;
52  ASSERT_TRUE(vector.push_back(0x1337));
53  ASSERT_EQ(vector[0], 0x1337);
54  ASSERT_EQ(vector.data()[0], 0x1337);
55}
56
57TEST(DynamicVector, PushBackReserveAndRead) {
58  DynamicVector<int> vector;
59  ASSERT_TRUE(vector.push_back(0x1337));
60  ASSERT_TRUE(vector.push_back(0xface));
61  ASSERT_TRUE(vector.reserve(4));
62  ASSERT_EQ(vector[0], 0x1337);
63  ASSERT_EQ(vector.data()[0], 0x1337);
64  ASSERT_EQ(vector[1], 0xface);
65  ASSERT_EQ(vector.data()[1], 0xface);
66}
67
68/**
69 * A simple test helper object to count number of construction and destructions.
70 */
71class Foo {
72 public:
73  /**
74   * Construct an object storing a simple integer. Increment the number of
75   * objects that have been constructed of this type.
76   */
77  Foo(int value) : value(value) {
78    sConstructedCounter++;
79  }
80
81  /**
82   * Tear down the object, decrementing the number of objects that have been
83   * constructed of this type.
84   */
85  ~Foo() {
86    sConstructedCounter--;
87  }
88
89  //! The number of objects of this type that have been constructed.
90  static size_t sConstructedCounter;
91
92  //! The value stored in the object to verify the contents of this object after
93  //! construction.
94  int value;
95};
96
97//! Storage for the Foo reference counter.
98size_t Foo::sConstructedCounter = 0;
99
100TEST(DynamicVector, EmplaceBackAndDestruct) {
101  {
102    DynamicVector<Foo> vector;
103    ASSERT_TRUE(vector.emplace_back(1000));
104    ASSERT_TRUE(vector.emplace_back(2000));
105    ASSERT_TRUE(vector.emplace_back(3000));
106    ASSERT_TRUE(vector.emplace_back(4000));
107
108    ASSERT_EQ(vector[0].value, 1000);
109    ASSERT_EQ(vector.data()[0].value, 1000);
110    ASSERT_EQ(vector[1].value, 2000);
111    ASSERT_EQ(vector.data()[1].value, 2000);
112    ASSERT_EQ(vector[2].value, 3000);
113    ASSERT_EQ(vector.data()[2].value, 3000);
114    ASSERT_EQ(vector[3].value, 4000);
115    ASSERT_EQ(vector.data()[3].value, 4000);
116
117    ASSERT_EQ(Foo::sConstructedCounter, 4);
118  }
119
120  ASSERT_EQ(Foo::sConstructedCounter, 0);
121}
122
123TEST(DynamicVector, InsertEmpty) {
124  DynamicVector<int> vector;
125  ASSERT_FALSE(vector.insert(1, 0x1337));
126  ASSERT_TRUE(vector.insert(0, 0x1337));
127  ASSERT_EQ(vector[0], 0x1337);
128  ASSERT_EQ(vector.data()[0], 0x1337);
129}
130
131TEST(DynamicVector, PushBackInsertInMiddleAndRead) {
132  DynamicVector<int> vector;
133  ASSERT_TRUE(vector.push_back(0x1337));
134  ASSERT_TRUE(vector.push_back(0xface));
135  ASSERT_TRUE(vector.push_back(0xcafe));
136  ASSERT_TRUE(vector.insert(1, 0xbeef));
137
138  ASSERT_EQ(vector[0], 0x1337);
139  ASSERT_EQ(vector.data()[0], 0x1337);
140  ASSERT_EQ(vector[1], 0xbeef);
141  ASSERT_EQ(vector.data()[1], 0xbeef);
142  ASSERT_EQ(vector[2], 0xface);
143  ASSERT_EQ(vector.data()[2], 0xface);
144  ASSERT_EQ(vector[3], 0xcafe);
145  ASSERT_EQ(vector.data()[3], 0xcafe);
146}
147
148TEST(DynamicVector, PushBackAndErase) {
149  DynamicVector<int> vector;
150  ASSERT_TRUE(vector.push_back(0x1337));
151  ASSERT_TRUE(vector.push_back(0xcafe));
152  ASSERT_TRUE(vector.push_back(0xbeef));
153  ASSERT_TRUE(vector.push_back(0xface));
154
155  vector.erase(1);
156
157  ASSERT_EQ(vector[0], 0x1337);
158  ASSERT_EQ(vector.data()[0], 0x1337);
159  ASSERT_EQ(vector[1], 0xbeef);
160  ASSERT_EQ(vector.data()[1], 0xbeef);
161  ASSERT_EQ(vector[2], 0xface);
162  ASSERT_EQ(vector.data()[2], 0xface);
163  ASSERT_EQ(vector.size(), 3);
164}
165
166TEST(DynamicVector, FindEmpty) {
167  DynamicVector<int> vector;
168  ASSERT_EQ(vector.find(0), 0);
169}
170
171TEST(DynamicVector, FindWithElements) {
172  DynamicVector<int> vector;
173  ASSERT_TRUE(vector.push_back(0x1337));
174  ASSERT_TRUE(vector.push_back(0xcafe));
175  ASSERT_TRUE(vector.push_back(0xbeef));
176
177  ASSERT_EQ(vector.find(0x1337), 0);
178  ASSERT_EQ(vector.find(0xcafe), 1);
179  ASSERT_EQ(vector.find(0xbeef), 2);
180  ASSERT_EQ(vector.find(1000), 3);
181}
182
183TEST(FixedSizeVector, EraseDestructorCalled) {
184  DynamicVector<Dummy> vector;
185  for (size_t i = 0; i < 4; ++i) {
186    vector.push_back(Dummy());
187    vector[i].setValue(i);
188  }
189
190  // last item before erase is '3'.
191  vector.erase(1);
192  EXPECT_EQ(0, destructor_count[0]);
193  EXPECT_EQ(0, destructor_count[1]);
194  EXPECT_EQ(0, destructor_count[2]);
195  EXPECT_EQ(1, destructor_count[3]);
196
197  // last item before erase is still '3'.
198  vector.erase(2);
199  EXPECT_EQ(0, destructor_count[0]);
200  EXPECT_EQ(0, destructor_count[1]);
201  EXPECT_EQ(0, destructor_count[2]);
202  EXPECT_EQ(2, destructor_count[3]);
203
204  // last item before erase is now '2'.
205  vector.erase(0);
206  EXPECT_EQ(0, destructor_count[0]);
207  EXPECT_EQ(0, destructor_count[1]);
208  EXPECT_EQ(1, destructor_count[2]);
209  EXPECT_EQ(2, destructor_count[3]);
210}
211
212TEST(DynamicVectorDeathTest, SwapWithInvalidIndex) {
213  DynamicVector<int> vector;
214  vector.push_back(0x1337);
215  vector.push_back(0xcafe);
216  EXPECT_DEATH(vector.swap(0, 2), "");
217}
218
219TEST(DynamicVectorDeathTest, SwapWithInvalidIndices) {
220  DynamicVector<int> vector;
221  vector.push_back(0x1337);
222  vector.push_back(0xcafe);
223  EXPECT_DEATH(vector.swap(2, 3), "");
224}
225
226TEST(DynamicVector, Swap) {
227  DynamicVector<int> vector;
228  vector.push_back(0x1337);
229  vector.push_back(0xcafe);
230
231  vector.swap(0, 1);
232  EXPECT_EQ(vector[0], 0xcafe);
233  EXPECT_EQ(vector[1], 0x1337);
234}
235