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