1 /*
2 * Copyright (C) 2024 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 "minikin/PackedVector.h"
20
21 namespace minikin {
22
23 struct Data {
24 int x, y;
25 };
26
TEST(PackedVector,construct)27 TEST(PackedVector, construct) {
28 {
29 PackedVector<int> packed;
30 EXPECT_EQ(0u, packed.size());
31 EXPECT_TRUE(packed.empty());
32 }
33 {
34 int data[] = {1, 2, 3, 4, 5};
35
36 PackedVector<int> packed(data, 5);
37 EXPECT_EQ(5u, packed.size());
38 EXPECT_EQ(1, packed[0]);
39 EXPECT_EQ(2, packed[1]);
40 EXPECT_EQ(3, packed[2]);
41 EXPECT_EQ(4, packed[3]);
42 EXPECT_EQ(5, packed[4]);
43 }
44 {
45 int data[] = {1, 2, 3, 4, 5};
46
47 PackedVector<int> packed(data + 2, 2);
48 EXPECT_EQ(2u, packed.size());
49 EXPECT_EQ(3, packed[0]);
50 EXPECT_EQ(4, packed[1]);
51 }
52 {
53 std::vector<int> data = {1, 2, 3, 4, 5};
54
55 PackedVector<int> packed(data);
56 EXPECT_EQ(5u, packed.size());
57 EXPECT_EQ(1, packed[0]);
58 EXPECT_EQ(2, packed[1]);
59 EXPECT_EQ(3, packed[2]);
60 EXPECT_EQ(4, packed[3]);
61 EXPECT_EQ(5, packed[4]);
62 }
63 }
64
TEST(PackedVector,push_back)65 TEST(PackedVector, push_back) {
66 PackedVector<int> packed;
67
68 packed.push_back(0);
69 EXPECT_EQ(1u, packed.size());
70 EXPECT_FALSE(packed.empty());
71 EXPECT_EQ(0, packed[0]);
72 EXPECT_EQ(0, packed.data()[0]);
73 EXPECT_EQ(0, *packed.back());
74
75 packed.push_back(10);
76 EXPECT_EQ(2u, packed.size());
77 EXPECT_FALSE(packed.empty());
78 EXPECT_EQ(10, packed[1]);
79 EXPECT_EQ(10, packed.data()[1]);
80 EXPECT_EQ(10, *packed.back());
81 }
82
TEST(PackedVector,compare)83 TEST(PackedVector, compare) {
84 {
85 PackedVector<int> left = {1, 2, 3, 4, 5};
86 PackedVector<int> right = {1, 2, 3, 4, 5};
87
88 EXPECT_TRUE(left == right);
89 EXPECT_FALSE(left != right);
90 }
91 {
92 PackedVector<int> left = {1, 2, 3, 4, 5};
93 PackedVector<int> right = {1, 2, 3, 4, 5, 6};
94
95 EXPECT_FALSE(left == right);
96 EXPECT_TRUE(left != right);
97 }
98 {
99 PackedVector<int> left = {};
100 PackedVector<int> right = {};
101
102 EXPECT_TRUE(left == right);
103 EXPECT_FALSE(left != right);
104 }
105 {
106 PackedVector<Data> left = {{0, 1}, {2, 3}};
107 PackedVector<Data> right = {{0, 1}, {2, 3}};
108
109 EXPECT_TRUE(left == right);
110 EXPECT_FALSE(left != right);
111 }
112 {
113 PackedVector<Data> left = {{0, 1}, {2, 3}};
114 PackedVector<Data> right = {{0, 1}};
115
116 EXPECT_FALSE(left == right);
117 EXPECT_TRUE(left != right);
118 }
119 }
120
TEST(PackedVector,reserve)121 TEST(PackedVector, reserve) {
122 {
123 PackedVector<int> packed;
124 packed.reserve(100);
125 EXPECT_EQ(0u, packed.size());
126 EXPECT_EQ(100u, packed.capacity());
127 packed.shrink_to_fit();
128 EXPECT_EQ(0u, packed.size());
129 // The PackedVector has minimum capacity for the space of pointers. So cannot expect it
130 // becomes 0.
131 EXPECT_NE(100u, packed.capacity());
132 }
133 {
134 PackedVector<int> packed;
135 packed.reserve(100);
136 for (int i = 0; i < 50; ++i) {
137 packed.push_back(i);
138 }
139 EXPECT_EQ(50u, packed.size());
140 EXPECT_EQ(100u, packed.capacity());
141 packed.shrink_to_fit();
142 EXPECT_EQ(50u, packed.size());
143 EXPECT_EQ(50u, packed.capacity());
144 }
145 }
146
TEST(PackedVector,iterator)147 TEST(PackedVector, iterator) {
148 {
149 PackedVector<int> packed = {0, 1, 2, 3, 4, 5};
150 std::vector<int> copied(packed.begin(), packed.end());
151 EXPECT_EQ(std::vector<int>({0, 1, 2, 3, 4, 5}), copied);
152 }
153 }
154
TEST(PackedVector,resize)155 TEST(PackedVector, resize) {
156 {
157 // Reduction
158 PackedVector<int> packed = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
159 packed.resize(10);
160 EXPECT_EQ(10u, packed.size());
161 EXPECT_EQ(10u, packed.capacity());
162 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}), packed);
163
164 packed.resize(9);
165 EXPECT_EQ(9u, packed.size());
166 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6, 7, 8, 9}), packed);
167
168 packed.resize(8);
169 EXPECT_EQ(8u, packed.size());
170 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6, 7, 8}), packed);
171
172 packed.resize(7);
173 EXPECT_EQ(7u, packed.size());
174 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6, 7}), packed);
175
176 packed.resize(6);
177 EXPECT_EQ(6u, packed.size());
178 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6}), packed);
179
180 packed.resize(5);
181 EXPECT_EQ(5u, packed.size());
182 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5}), packed);
183
184 packed.resize(4);
185 EXPECT_EQ(4u, packed.size());
186 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4}), packed);
187
188 packed.resize(3);
189 EXPECT_EQ(3u, packed.size());
190 EXPECT_EQ(PackedVector<int>({1, 2, 3}), packed);
191
192 packed.resize(2);
193 EXPECT_EQ(2u, packed.size());
194 EXPECT_EQ(PackedVector<int>({1, 2}), packed);
195
196 packed.resize(1);
197 EXPECT_EQ(1u, packed.size());
198 EXPECT_EQ(PackedVector<int>({1}), packed);
199
200 packed.resize(0);
201 EXPECT_EQ(0u, packed.size());
202 EXPECT_EQ(PackedVector<int>({}), packed);
203 }
204 {
205 // Expansion
206 PackedVector<int> packed = {};
207 packed.resize(1, 1);
208 EXPECT_EQ(1u, packed.size());
209 EXPECT_EQ(PackedVector<int>({1}), packed);
210
211 packed.resize(2, 2);
212 EXPECT_EQ(2u, packed.size());
213 EXPECT_EQ(PackedVector<int>({1, 2}), packed);
214
215 packed.resize(3, 3);
216 EXPECT_EQ(3u, packed.size());
217 EXPECT_EQ(PackedVector<int>({1, 2, 3}), packed);
218
219 packed.resize(4, 4);
220 EXPECT_EQ(4u, packed.size());
221 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4}), packed);
222
223 packed.resize(5, 5);
224 EXPECT_EQ(5u, packed.size());
225 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5}), packed);
226
227 packed.resize(6, 6);
228 EXPECT_EQ(6u, packed.size());
229 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6}), packed);
230
231 packed.resize(7, 7);
232 EXPECT_EQ(7u, packed.size());
233 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6, 7}), packed);
234
235 packed.resize(8, 8);
236 EXPECT_EQ(8u, packed.size());
237 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6, 7, 8}), packed);
238
239 packed.resize(9, 9);
240 EXPECT_EQ(9u, packed.size());
241 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6, 7, 8, 9}), packed);
242
243 packed.resize(10, 10);
244 EXPECT_EQ(10u, packed.size());
245 EXPECT_EQ(PackedVector<int>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}), packed);
246 }
247 }
248 } // namespace minikin
249