1 /*
2 * Copyright (C) 2019 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 "src/trace_processor/containers/row_map.h"
18
19 #include <memory>
20
21 #include "test/gtest_and_gmock.h"
22
23 namespace perfetto {
24 namespace trace_processor {
25 namespace {
26
TEST(RowMapUnittest,SingleRow)27 TEST(RowMapUnittest, SingleRow) {
28 RowMap rm(10, 20);
29 RowMap rm_row = rm.SingleRow(15u);
30 ASSERT_EQ(rm_row.size(), 1u);
31 ASSERT_TRUE(rm_row.Contains(15));
32 ASSERT_FALSE(rm_row.Contains(11));
33 }
34
TEST(RowMapUnittest,CopyRange)35 TEST(RowMapUnittest, CopyRange) {
36 RowMap rm(10, 20);
37 RowMap rm_copy = rm.Copy();
38 ASSERT_EQ(rm_copy.size(), 10u);
39 }
40
TEST(RowMapUnittest,CopyBitVector)41 TEST(RowMapUnittest, CopyBitVector) {
42 RowMap rm(BitVector{true, false, false, false, true, true});
43 RowMap rm_copy = rm.Copy();
44 ASSERT_EQ(rm_copy.size(), 3u);
45 }
46
TEST(RowMapUnittest,CopyIndexVector)47 TEST(RowMapUnittest, CopyIndexVector) {
48 RowMap rm(std::vector<uint32_t>{10, 17, 20, 21});
49 RowMap rm_copy = rm.Copy();
50 ASSERT_EQ(rm_copy.size(), 4u);
51 }
52
TEST(RowMapUnittest,GetFromRange)53 TEST(RowMapUnittest, GetFromRange) {
54 RowMap rm(10, 20);
55 ASSERT_EQ(rm.Get(5), 15u);
56 }
57
TEST(RowMapUnittest,GetFromBitVector)58 TEST(RowMapUnittest, GetFromBitVector) {
59 RowMap rm(BitVector{true, false, false, false, true, true});
60 ASSERT_EQ(rm.Get(1), 4u);
61 }
62
TEST(RowMapUnittest,GetFromIndexVector)63 TEST(RowMapUnittest, GetFromIndexVector) {
64 RowMap rm(std::vector<uint32_t>{10, 17, 20, 21});
65 ASSERT_EQ(rm.Get(1), 17u);
66 }
67
TEST(RowMapUnittest,ContainsFromRange)68 TEST(RowMapUnittest, ContainsFromRange) {
69 RowMap rm(10, 20);
70 ASSERT_FALSE(rm.Contains(5));
71 ASSERT_TRUE(rm.Contains(15));
72 }
73
TEST(RowMapUnittest,ContainsFromBitVector)74 TEST(RowMapUnittest, ContainsFromBitVector) {
75 RowMap rm(BitVector{true, false, false, false, true, true});
76 ASSERT_FALSE(rm.Contains(3));
77 ASSERT_TRUE(rm.Contains(5));
78 }
79
TEST(RowMapUnittest,ContainsFromIndexVector)80 TEST(RowMapUnittest, ContainsFromIndexVector) {
81 RowMap rm(std::vector<uint32_t>{10, 17, 20, 21});
82 ASSERT_FALSE(rm.Contains(5));
83 ASSERT_TRUE(rm.Contains(10));
84 }
85
TEST(RowMapUnittest,RowOfRange)86 TEST(RowMapUnittest, RowOfRange) {
87 RowMap rm(10, 20);
88 ASSERT_EQ(rm.RowOf(15).value(), 5u);
89 ASSERT_EQ(rm.RowOf(5), std::nullopt);
90 }
91
TEST(RowMapUnittest,RowOfBitVector)92 TEST(RowMapUnittest, RowOfBitVector) {
93 RowMap rm(BitVector{true, false, false, false, true, true});
94 ASSERT_EQ(rm.RowOf(4), 1u);
95 ASSERT_EQ(rm.RowOf(1), std::nullopt);
96 }
97
TEST(RowMapUnittest,RowOfIndexVector)98 TEST(RowMapUnittest, RowOfIndexVector) {
99 RowMap rm(std::vector<uint32_t>{10, 17, 20, 21});
100 ASSERT_EQ(rm.RowOf(17), 1u);
101 ASSERT_EQ(rm.RowOf(5), std::nullopt);
102 }
103
TEST(RowMapUnittest,InsertIntoRangeAtTheEnd)104 TEST(RowMapUnittest, InsertIntoRangeAtTheEnd) {
105 RowMap rm(10, 20);
106 rm.Insert(21);
107 ASSERT_EQ(rm.size(), 11u);
108 ASSERT_TRUE(rm.Contains(21));
109 }
110
TEST(RowMapUnittest,InsertIntoRange)111 TEST(RowMapUnittest, InsertIntoRange) {
112 RowMap rm(10, 20);
113 rm.Insert(25);
114 ASSERT_EQ(rm.size(), 11u);
115 ASSERT_TRUE(rm.Contains(25));
116 }
117
TEST(RowMapUnittest,InsertIntoBitVector)118 TEST(RowMapUnittest, InsertIntoBitVector) {
119 RowMap rm(BitVector{true, false, false, false, true, true});
120 rm.Insert(25);
121 ASSERT_EQ(rm.size(), 4u);
122 ASSERT_TRUE(rm.Contains(25));
123 }
124
TEST(RowMapUnittest,InsertIntoIndexVector)125 TEST(RowMapUnittest, InsertIntoIndexVector) {
126 RowMap rm(std::vector<uint32_t>{10, 17, 20, 21});
127 rm.Insert(25);
128 ASSERT_EQ(rm.size(), 5u);
129 ASSERT_TRUE(rm.Contains(25));
130 }
131
TEST(RowMapUnittest,SelectRowsFromRangeWithRange)132 TEST(RowMapUnittest, SelectRowsFromRangeWithRange) {
133 RowMap rm(10, 20);
134
135 RowMap selector(4, 8);
136 RowMap selected = rm.SelectRows(selector);
137 ASSERT_EQ(selected.size(), 4u);
138 ASSERT_EQ(selected.Get(0), 14u);
139 }
140
TEST(RowMapUnittest,SelectRowsFromRangeWithBV)141 TEST(RowMapUnittest, SelectRowsFromRangeWithBV) {
142 RowMap rm(10, 20);
143 // BitVector with values at 16, 18, 20 and so on.
144 RowMap selector(
145 BitVector::RangeForTesting(4, 8, [](uint32_t x) { return x % 2 == 0; }));
146 RowMap selected = rm.SelectRows(selector);
147 ASSERT_EQ(selected.size(), 2u);
148 ASSERT_EQ(selected.Get(0), 14u);
149 }
150
TEST(RowMapUnittest,SelectRowsFromRangeWithIV)151 TEST(RowMapUnittest, SelectRowsFromRangeWithIV) {
152 RowMap rm(10, 20);
153 RowMap selector(std::vector<uint32_t>{4, 6});
154 RowMap selected = rm.SelectRows(selector);
155 ASSERT_EQ(selected.size(), 2u);
156 ASSERT_EQ(selected.Get(0), 14u);
157 }
158
TEST(RowMapUnittest,SelectRowsFromBVWithRange)159 TEST(RowMapUnittest, SelectRowsFromBVWithRange) {
160 RowMap rm(BitVector::RangeForTesting(10, 50,
161 [](uint32_t x) { return x % 2 == 0; }));
162
163 RowMap selector(4, 8);
164 RowMap selected = rm.SelectRows(selector);
165 ASSERT_EQ(selected.size(), 4u);
166 ASSERT_EQ(selected.Get(0), 18u);
167 }
168
TEST(RowMapUnittest,SelectRowsFromBVWithBV)169 TEST(RowMapUnittest, SelectRowsFromBVWithBV) {
170 RowMap rm(BitVector::RangeForTesting(10, 50,
171 [](uint32_t x) { return x % 2 == 0; }));
172 // BitVector with values at 16, 18, 20 and so on.
173 RowMap selector(
174 BitVector::RangeForTesting(4, 8, [](uint32_t x) { return x % 2 == 0; }));
175 RowMap selected = rm.SelectRows(selector);
176 ASSERT_EQ(selected.size(), 2u);
177 ASSERT_EQ(selected.Get(0), 18u);
178 }
179
TEST(RowMapUnittest,SelectRowsFromBVWithIV)180 TEST(RowMapUnittest, SelectRowsFromBVWithIV) {
181 RowMap rm(BitVector::RangeForTesting(10, 50,
182 [](uint32_t x) { return x % 2 == 0; }));
183 RowMap selector(std::vector<uint32_t>{4, 6});
184 RowMap selected = rm.SelectRows(selector);
185 ASSERT_EQ(selected.size(), 2u);
186 ASSERT_EQ(selected.Get(0), 18u);
187 }
188
TEST(RowMapUnittest,SelectRowsFromIVWithRange)189 TEST(RowMapUnittest, SelectRowsFromIVWithRange) {
190 RowMap rm(std::vector<uint32_t>{10, 12, 14, 16, 18, 20, 22, 24});
191
192 RowMap selector(4, 8);
193 RowMap selected = rm.SelectRows(selector);
194 ASSERT_EQ(selected.size(), 4u);
195 ASSERT_EQ(selected.Get(0), 18u);
196 }
197
TEST(RowMapUnittest,SelectRowsFromIVWithBV)198 TEST(RowMapUnittest, SelectRowsFromIVWithBV) {
199 RowMap rm(std::vector<uint32_t>{10, 12, 14, 16, 18, 20, 22, 24});
200 RowMap selector(
201 BitVector::RangeForTesting(4, 8, [](uint32_t x) { return x % 2 == 0; }));
202 RowMap selected = rm.SelectRows(selector);
203 ASSERT_EQ(selected.size(), 2u);
204 ASSERT_EQ(selected.Get(0), 18u);
205 }
206
TEST(RowMapUnittest,SelectRowsFromIVWithIV)207 TEST(RowMapUnittest, SelectRowsFromIVWithIV) {
208 RowMap rm(std::vector<uint32_t>{10, 12, 14, 16, 18, 20, 22, 24});
209 RowMap selector(std::vector<uint32_t>{4, 6});
210 RowMap selected = rm.SelectRows(selector);
211 ASSERT_EQ(selected.size(), 2u);
212 ASSERT_EQ(selected.Get(0), 18u);
213 }
214
TEST(RowMapUnittest,SmokeRange)215 TEST(RowMapUnittest, SmokeRange) {
216 RowMap rm(30, 47);
217
218 ASSERT_EQ(rm.size(), 17u);
219
220 ASSERT_EQ(rm.Get(0), 30u);
221 ASSERT_EQ(rm.Get(1), 31u);
222 ASSERT_EQ(rm.Get(16), 46u);
223
224 ASSERT_EQ(rm.RowOf(29), std::nullopt);
225 ASSERT_EQ(rm.RowOf(30), 0u);
226 ASSERT_EQ(rm.RowOf(37), 7u);
227 ASSERT_EQ(rm.RowOf(46), 16u);
228 ASSERT_EQ(rm.RowOf(47), std::nullopt);
229 }
230
TEST(RowMapUnittest,SmokeBitVector)231 TEST(RowMapUnittest, SmokeBitVector) {
232 RowMap rm(BitVector{true, false, false, false, true, true});
233
234 ASSERT_EQ(rm.size(), 3u);
235
236 ASSERT_EQ(rm.Get(0u), 0u);
237 ASSERT_EQ(rm.Get(1u), 4u);
238 ASSERT_EQ(rm.Get(2u), 5u);
239
240 ASSERT_EQ(rm.RowOf(0u), 0u);
241 ASSERT_EQ(rm.RowOf(4u), 1u);
242 ASSERT_EQ(rm.RowOf(5u), 2u);
243
244 ASSERT_EQ(rm.RowOf(1u), std::nullopt);
245 ASSERT_EQ(rm.RowOf(100u), std::nullopt);
246 }
247
TEST(RowMapUnittest,SmokeIndexVector)248 TEST(RowMapUnittest, SmokeIndexVector) {
249 RowMap rm(std::vector<uint32_t>{32u, 56u, 24u, 0u, 100u, 1u});
250
251 ASSERT_EQ(rm.size(), 6u);
252
253 ASSERT_EQ(rm.Get(0u), 32u);
254 ASSERT_EQ(rm.Get(1u), 56u);
255 ASSERT_EQ(rm.Get(2u), 24u);
256 ASSERT_EQ(rm.Get(3u), 0u);
257 ASSERT_EQ(rm.Get(4u), 100u);
258 ASSERT_EQ(rm.Get(5u), 1u);
259
260 ASSERT_EQ(rm.RowOf(32u), 0u);
261 ASSERT_EQ(rm.RowOf(56u), 1u);
262 ASSERT_EQ(rm.RowOf(24u), 2u);
263 ASSERT_EQ(rm.RowOf(0u), 3u);
264 ASSERT_EQ(rm.RowOf(100u), 4u);
265 ASSERT_EQ(rm.RowOf(1u), 5u);
266 }
267
TEST(RowMapUnittest,InsertToRangeAfter)268 TEST(RowMapUnittest, InsertToRangeAfter) {
269 RowMap rm(3u, 7u);
270 rm.Insert(10u);
271
272 ASSERT_EQ(rm.size(), 5u);
273 ASSERT_EQ(rm.Get(4u), 10u);
274 ASSERT_EQ(rm.RowOf(10u), 4u);
275 }
276
TEST(RowMapUnittest,InsertToBitVectorBefore)277 TEST(RowMapUnittest, InsertToBitVectorBefore) {
278 RowMap rm(BitVector{true, false, true, true, false, true});
279 rm.Insert(1u);
280
281 ASSERT_EQ(rm.size(), 5u);
282 ASSERT_EQ(rm.Get(0u), 0u);
283 ASSERT_EQ(rm.Get(1u), 1u);
284 ASSERT_EQ(rm.Get(2u), 2u);
285 ASSERT_EQ(rm.Get(3u), 3u);
286 ASSERT_EQ(rm.Get(4u), 5u);
287 }
288
TEST(RowMapUnittest,InsertToBitVectorAfter)289 TEST(RowMapUnittest, InsertToBitVectorAfter) {
290 RowMap rm(BitVector{true, false, true, true, false, true});
291 rm.Insert(10u);
292
293 ASSERT_EQ(rm.size(), 5u);
294 ASSERT_EQ(rm.Get(4u), 10u);
295 ASSERT_EQ(rm.RowOf(10u), 4u);
296 }
297
TEST(RowMapUnittest,InsertToIndexVectorAfter)298 TEST(RowMapUnittest, InsertToIndexVectorAfter) {
299 RowMap rm(std::vector<uint32_t>{0u, 2u, 3u, 5u});
300 rm.Insert(10u);
301
302 ASSERT_EQ(rm.size(), 5u);
303 ASSERT_EQ(rm.Get(4u), 10u);
304 ASSERT_EQ(rm.RowOf(10u), 4u);
305 }
306
TEST(RowMapUnittest,ContainsRange)307 TEST(RowMapUnittest, ContainsRange) {
308 RowMap rm(93, 157);
309
310 ASSERT_TRUE(rm.Contains(93));
311 ASSERT_TRUE(rm.Contains(105));
312 ASSERT_TRUE(rm.Contains(156));
313
314 ASSERT_FALSE(rm.Contains(0));
315 ASSERT_FALSE(rm.Contains(92));
316 ASSERT_FALSE(rm.Contains(157));
317 }
318
TEST(RowMapUnittest,ContainsBitVector)319 TEST(RowMapUnittest, ContainsBitVector) {
320 RowMap rm(BitVector{true, false, true, true, false, true});
321
322 ASSERT_TRUE(rm.Contains(0));
323 ASSERT_TRUE(rm.Contains(2));
324 ASSERT_TRUE(rm.Contains(3));
325
326 ASSERT_FALSE(rm.Contains(1));
327 ASSERT_FALSE(rm.Contains(4));
328 ASSERT_FALSE(rm.Contains(6));
329 }
330
TEST(RowMapUnittest,ContainsIndexVector)331 TEST(RowMapUnittest, ContainsIndexVector) {
332 RowMap rm(std::vector<uint32_t>{0u, 2u, 3u, 5u});
333
334 ASSERT_TRUE(rm.Contains(0));
335 ASSERT_TRUE(rm.Contains(2));
336 ASSERT_TRUE(rm.Contains(3));
337
338 ASSERT_FALSE(rm.Contains(1));
339 ASSERT_FALSE(rm.Contains(4));
340 ASSERT_FALSE(rm.Contains(6));
341 }
342
TEST(RowMapUnittest,OutputSizeIV)343 TEST(RowMapUnittest, OutputSizeIV) {
344 RowMap rm(std::vector<uint32_t>{0u, 2u, 3u, 5u});
345 ASSERT_EQ(rm.Max(), 6u);
346 }
347
TEST(RowMapUnittest,OutputSizeRange)348 TEST(RowMapUnittest, OutputSizeRange) {
349 RowMap rm(0, 10);
350 ASSERT_EQ(rm.Max(), 10u);
351 }
352
TEST(RowMapUnittest,OutputSizeBV)353 TEST(RowMapUnittest, OutputSizeBV) {
354 RowMap rm(BitVector{0, 1, 0, 1, 0, 1, 0});
355 ASSERT_EQ(rm.Max(), 7u);
356 }
357
TEST(RowMapUnittest,SelectRangeWithRange)358 TEST(RowMapUnittest, SelectRangeWithRange) {
359 RowMap rm(93, 157);
360 RowMap picker(4, 7);
361 auto res = rm.SelectRows(picker);
362
363 ASSERT_EQ(res.size(), 3u);
364 ASSERT_EQ(res.Get(0u), 97u);
365 ASSERT_EQ(res.Get(1u), 98u);
366 ASSERT_EQ(res.Get(2u), 99u);
367 }
368
TEST(RowMapUnittest,SelectBitVectorWithRange)369 TEST(RowMapUnittest, SelectBitVectorWithRange) {
370 RowMap rm(BitVector{true, false, false, true, false, true, false});
371 RowMap picker(1u, 3u);
372 auto res = rm.SelectRows(picker);
373
374 ASSERT_EQ(res.size(), 2u);
375 ASSERT_EQ(res.Get(0u), 3u);
376 ASSERT_EQ(res.Get(1u), 5u);
377 }
378
TEST(RowMapUnittest,SelectIndexVectorWithRange)379 TEST(RowMapUnittest, SelectIndexVectorWithRange) {
380 RowMap rm(std::vector<uint32_t>{33, 2u, 45u, 7u, 8u, 9u});
381 RowMap picker(2, 5);
382 auto res = rm.SelectRows(picker);
383
384 ASSERT_EQ(res.size(), 3u);
385 ASSERT_EQ(res.Get(0u), 45u);
386 ASSERT_EQ(res.Get(1u), 7u);
387 ASSERT_EQ(res.Get(2u), 8u);
388 }
389
TEST(RowMapUnittest,SelectRangeWithBitVector)390 TEST(RowMapUnittest, SelectRangeWithBitVector) {
391 RowMap rm(27, 31);
392 RowMap picker(BitVector{true, false, false, true});
393 auto res = rm.SelectRows(picker);
394
395 ASSERT_EQ(res.size(), 2u);
396 ASSERT_EQ(res.Get(0u), 27u);
397 ASSERT_EQ(res.Get(1u), 30u);
398 }
399
TEST(RowMapUnittest,SelectRangeWithSingleBitVector)400 TEST(RowMapUnittest, SelectRangeWithSingleBitVector) {
401 RowMap rm(27, 31);
402 RowMap picker(BitVector{false, true});
403 auto res = rm.SelectRows(picker);
404
405 ASSERT_EQ(res.size(), 1u);
406 ASSERT_EQ(res.Get(0u), 28u);
407 }
408
TEST(RowMapUnittest,SelectRangeWithSmallBitVector)409 TEST(RowMapUnittest, SelectRangeWithSmallBitVector) {
410 RowMap rm(27, 31);
411 RowMap picker(BitVector{false, true, true});
412 auto res = rm.SelectRows(picker);
413
414 ASSERT_EQ(res.size(), 2u);
415 ASSERT_EQ(res.Get(0u), 28u);
416 ASSERT_EQ(res.Get(1u), 29u);
417 }
418
TEST(RowMapUnittest,SelectBitVectorWithBitVector)419 TEST(RowMapUnittest, SelectBitVectorWithBitVector) {
420 RowMap rm(BitVector{true, false, true, true, false, true});
421 RowMap picker(BitVector{true, false, false, true});
422 auto res = rm.SelectRows(picker);
423
424 ASSERT_EQ(res.size(), 2u);
425 ASSERT_EQ(res.Get(0u), 0u);
426 ASSERT_EQ(res.Get(1u), 5u);
427 }
428
TEST(RowMapUnittest,SelectBitVectorWithSingleBitVector)429 TEST(RowMapUnittest, SelectBitVectorWithSingleBitVector) {
430 RowMap rm(BitVector{true, false, true, true, false, true});
431 RowMap picker(BitVector{false, true});
432 auto res = rm.SelectRows(picker);
433
434 ASSERT_EQ(res.size(), 1u);
435 ASSERT_EQ(res.Get(0u), 2u);
436 }
437
TEST(RowMapUnittest,SelectBitVectorWithSmallBitVector)438 TEST(RowMapUnittest, SelectBitVectorWithSmallBitVector) {
439 RowMap rm(BitVector{true, false, true, true, false, true});
440 RowMap picker(BitVector{false, true, true});
441 auto res = rm.SelectRows(picker);
442
443 ASSERT_EQ(res.size(), 2u);
444 ASSERT_EQ(res.Get(0u), 2u);
445 ASSERT_EQ(res.Get(1u), 3u);
446 }
447
TEST(RowMapUnittest,SelectIndexVectorWithBitVector)448 TEST(RowMapUnittest, SelectIndexVectorWithBitVector) {
449 RowMap rm(std::vector<uint32_t>{0u, 2u, 3u, 5u});
450 RowMap picker(BitVector{true, false, false, true});
451 auto res = rm.SelectRows(picker);
452
453 ASSERT_EQ(res.size(), 2u);
454 ASSERT_EQ(res.Get(0u), 0u);
455 ASSERT_EQ(res.Get(1u), 5u);
456 }
457
TEST(RowMapUnittest,SelectIndexVectorWithSmallBitVector)458 TEST(RowMapUnittest, SelectIndexVectorWithSmallBitVector) {
459 RowMap rm(std::vector<uint32_t>{0u, 2u, 3u, 5u});
460 RowMap picker(BitVector{false, true, true});
461 auto res = rm.SelectRows(picker);
462
463 ASSERT_EQ(res.size(), 2u);
464 ASSERT_EQ(res.Get(0u), 2u);
465 ASSERT_EQ(res.Get(1u), 3u);
466 }
467
TEST(RowMapUnittest,SelectRangeWithIndexVector)468 TEST(RowMapUnittest, SelectRangeWithIndexVector) {
469 RowMap rm(27, 31);
470 RowMap picker(std::vector<uint32_t>{3u, 2u, 0u, 1u, 1u, 3u});
471 auto res = rm.SelectRows(picker);
472
473 ASSERT_EQ(res.size(), 6u);
474 ASSERT_EQ(res.Get(0u), 30u);
475 ASSERT_EQ(res.Get(1u), 29u);
476 ASSERT_EQ(res.Get(2u), 27u);
477 ASSERT_EQ(res.Get(3u), 28u);
478 ASSERT_EQ(res.Get(4u), 28u);
479 ASSERT_EQ(res.Get(5u), 30u);
480 }
481
TEST(RowMapUnittest,SelectBitVectorWithIndexVector)482 TEST(RowMapUnittest, SelectBitVectorWithIndexVector) {
483 RowMap rm(BitVector{true, false, true, true, false, true});
484 RowMap picker(std::vector<uint32_t>{3u, 2u, 0u, 1u, 1u, 3u});
485 auto res = rm.SelectRows(picker);
486
487 ASSERT_EQ(res.size(), 6u);
488 ASSERT_EQ(res.Get(0u), 5u);
489 ASSERT_EQ(res.Get(1u), 3u);
490 ASSERT_EQ(res.Get(2u), 0u);
491 ASSERT_EQ(res.Get(3u), 2u);
492 ASSERT_EQ(res.Get(4u), 2u);
493 ASSERT_EQ(res.Get(5u), 5u);
494 }
495
TEST(RowMapUnittest,SelectIndexVectorWithIndexVector)496 TEST(RowMapUnittest, SelectIndexVectorWithIndexVector) {
497 RowMap rm(std::vector<uint32_t>{33u, 2u, 45u, 7u, 8u, 9u});
498 RowMap picker(std::vector<uint32_t>{3u, 2u, 0u, 1u, 1u, 3u});
499 auto res = rm.SelectRows(picker);
500
501 ASSERT_EQ(res.size(), 6u);
502 ASSERT_EQ(res.Get(0u), 7u);
503 ASSERT_EQ(res.Get(1u), 45u);
504 ASSERT_EQ(res.Get(2u), 33u);
505 ASSERT_EQ(res.Get(3u), 2u);
506 ASSERT_EQ(res.Get(4u), 2u);
507 ASSERT_EQ(res.Get(5u), 7u);
508 }
509
TEST(RowMapUnittest,Clear)510 TEST(RowMapUnittest, Clear) {
511 RowMap rm(BitVector{true, false, true, true, false, true});
512 rm.Clear();
513
514 ASSERT_EQ(rm.size(), 0u);
515 }
516
TEST(RowMapUnittest,IntersectSinglePresent)517 TEST(RowMapUnittest, IntersectSinglePresent) {
518 RowMap rm(BitVector{true, false, true, true, false, true});
519 rm.IntersectExact(2u);
520
521 ASSERT_EQ(rm.size(), 1u);
522 ASSERT_EQ(rm.Get(0u), 2u);
523 }
524
TEST(RowMapUnittest,IntersectSingleAbsent)525 TEST(RowMapUnittest, IntersectSingleAbsent) {
526 RowMap rm(BitVector{true, false, true, true, false, true});
527 rm.IntersectExact(1u);
528
529 ASSERT_EQ(rm.size(), 0u);
530 }
531
TEST(RowMapUnittest,IntersectRangeWithRange)532 TEST(RowMapUnittest, IntersectRangeWithRange) {
533 RowMap rm(3, 7);
534 RowMap sec(2, 4);
535 rm.Intersect(sec);
536
537 ASSERT_EQ(rm.size(), 1u);
538 ASSERT_EQ(rm.Get(0u), 3u);
539 }
540
TEST(RowMapUnittest,IntersectRangeWithBV)541 TEST(RowMapUnittest, IntersectRangeWithBV) {
542 RowMap rm(2, 4);
543 RowMap sec(BitVector{true, false, true, true, false, true});
544 rm.Intersect(sec);
545
546 ASSERT_EQ(rm.size(), 2u);
547 ASSERT_EQ(rm.Get(0), 2u);
548 }
549
TEST(RowMapUnittest,IntersectRangeWithIV)550 TEST(RowMapUnittest, IntersectRangeWithIV) {
551 RowMap rm(2, 10);
552 RowMap sec(std::vector<uint32_t>{0, 2, 5});
553 rm.Intersect(sec);
554
555 ASSERT_EQ(rm.size(), 2u);
556 ASSERT_EQ(rm.Get(0u), 2u);
557 }
558
TEST(RowMapUnittest,IntersectBVWithRange)559 TEST(RowMapUnittest, IntersectBVWithRange) {
560 RowMap rm(BitVector{true, false, true, true, false, true});
561 RowMap sec(2, 4);
562 rm.Intersect(sec);
563
564 ASSERT_EQ(rm.size(), 2u);
565 ASSERT_EQ(rm.Get(0), 2u);
566 }
567
TEST(RowMapUnittest,IntersectBVWithBV)568 TEST(RowMapUnittest, IntersectBVWithBV) {
569 RowMap rm(BitVector{true, false, true, true, false, true});
570 RowMap sec(BitVector{false, true, true, false, false, true, true});
571 rm.Intersect(sec);
572
573 ASSERT_EQ(rm.size(), 2u);
574 ASSERT_EQ(rm.Get(0), 2u);
575 }
576
TEST(RowMapUnittest,IntersectBVWithIV)577 TEST(RowMapUnittest, IntersectBVWithIV) {
578 RowMap rm(BitVector{true, false, true, true, false, true});
579 RowMap sec(std::vector<uint32_t>{0, 2, 5});
580 rm.Intersect(sec);
581
582 ASSERT_EQ(rm.size(), 3u);
583 ASSERT_EQ(rm.Get(0), 0u);
584 }
585
TEST(RowMapUnittest,IntersectIVWithRange)586 TEST(RowMapUnittest, IntersectIVWithRange) {
587 RowMap rm(std::vector<uint32_t>{0, 2, 5});
588 RowMap sec(2, 10);
589 rm.Intersect(sec);
590
591 ASSERT_EQ(rm.size(), 2u);
592 ASSERT_EQ(rm.Get(0u), 2u);
593 }
594
TEST(RowMapUnittest,IntersectIVWithBV)595 TEST(RowMapUnittest, IntersectIVWithBV) {
596 RowMap rm(std::vector<uint32_t>{0, 2, 5});
597 RowMap sec(BitVector{true, false, true, true, false, true});
598 rm.Intersect(sec);
599
600 ASSERT_EQ(rm.size(), 3u);
601 ASSERT_EQ(rm.Get(0), 0u);
602 }
603
TEST(RowMapUnittest,IntersectIVWithIV)604 TEST(RowMapUnittest, IntersectIVWithIV) {
605 RowMap rm(std::vector<uint32_t>{0, 2, 5});
606 RowMap sec(std::vector<uint32_t>{1, 2, 6});
607
608 rm.Intersect(sec);
609
610 ASSERT_EQ(rm.size(), 1u);
611 ASSERT_EQ(rm.Get(0u), 2u);
612 }
613
614 } // namespace
615 } // namespace trace_processor
616 } // namespace perfetto
617