1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "constant.h"
18 #include "permission_record_set.h"
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace Security {
24 namespace AccessToken {
25 namespace {
26 static constexpr int32_t HAP_TOKEN_ID[] = {101, 102};
27 static constexpr int32_t HAP_PID[] = {201, 202};
28 static constexpr int32_t INACTIVE = ActiveChangeType::PERM_INACTIVE;
29 static constexpr int32_t ACTIVE = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND;
30 static constexpr int32_t CALLER_PID[] = {301, 302};
31 static constexpr int32_t OPCODE[] = {Constant::OP_MICROPHONE, Constant::OP_CAMERA};
32 static constexpr int32_t RECORD_ITEM_SIZE = 5;
33 static constexpr int32_t SECOND_PARAM = 2;
34 static constexpr int32_t THIRD_PARAM = 3;
35 static constexpr int32_t FORTH_PARAM = 4;
36 }
37
MakeRecord(const int32_t recordArray[RECORD_ITEM_SIZE])38 static ContinusPermissionRecord MakeRecord(const int32_t recordArray[RECORD_ITEM_SIZE])
39 {
40 ContinusPermissionRecord record;
41 record.tokenId = recordArray[0];
42 record.opCode = recordArray[1];
43 record.status = recordArray[SECOND_PARAM];
44 record.pid = recordArray[THIRD_PARAM];
45 record.callerPid = recordArray[FORTH_PARAM];
46 return record;
47 }
48
MakeRecordSet(const int32_t recordArray[][RECORD_ITEM_SIZE],int32_t setSize,std::set<ContinusPermissionRecord> & recordSet)49 static void MakeRecordSet(const int32_t recordArray[][RECORD_ITEM_SIZE], int32_t setSize,
50 std::set<ContinusPermissionRecord>& recordSet)
51 {
52 for (size_t i = 0; i < setSize; i++) {
53 ContinusPermissionRecord record = MakeRecord(recordArray[i]);
54 recordSet.emplace(record);
55 }
56 }
57
MakeRecordList(const int32_t recordArray[][RECORD_ITEM_SIZE],int32_t setSize,std::vector<ContinusPermissionRecord> & recordList)58 static void MakeRecordList(const int32_t recordArray[][RECORD_ITEM_SIZE], int32_t setSize,
59 std::vector<ContinusPermissionRecord>& recordList)
60 {
61 for (size_t i = 0; i < setSize; i++) {
62 ContinusPermissionRecord record = MakeRecord(recordArray[i]);
63 recordList.emplace_back(record);
64 }
65 }
66
RemoveRecord(std::set<ContinusPermissionRecord> & recordList,const ContinusPermissionRecord & record,std::vector<ContinusPermissionRecord> & retList)67 static void RemoveRecord(std::set<ContinusPermissionRecord>& recordList,
68 const ContinusPermissionRecord& record, std::vector<ContinusPermissionRecord>& retList)
69 {
70 return PermissionRecordSet::RemoveByKey(recordList, record, &ContinusPermissionRecord::IsEqualRecord, retList);
71 }
72
RemoveTokenId(std::set<ContinusPermissionRecord> & recordList,const ContinusPermissionRecord & record,std::vector<ContinusPermissionRecord> & retList)73 static void RemoveTokenId(std::set<ContinusPermissionRecord>& recordList,
74 const ContinusPermissionRecord& record, std::vector<ContinusPermissionRecord>& retList)
75 {
76 return PermissionRecordSet::RemoveByKey(recordList, record, &ContinusPermissionRecord::IsEqualTokenId, retList);
77 }
78
RemoveTokenIdAndPid(std::set<ContinusPermissionRecord> & recordList,const ContinusPermissionRecord & record,std::vector<ContinusPermissionRecord> & retList)79 static void RemoveTokenIdAndPid(std::set<ContinusPermissionRecord>& recordList,
80 const ContinusPermissionRecord& record, std::vector<ContinusPermissionRecord>& retList)
81 {
82 return PermissionRecordSet::RemoveByKey(recordList, record,
83 &ContinusPermissionRecord::IsEqualTokenIdAndPid, retList);
84 }
85
RemovePermCode(std::set<ContinusPermissionRecord> & recordList,const ContinusPermissionRecord & record,std::vector<ContinusPermissionRecord> & retList)86 static void RemovePermCode(std::set<ContinusPermissionRecord>& recordList,
87 const ContinusPermissionRecord& record, std::vector<ContinusPermissionRecord>& retList)
88 {
89 return PermissionRecordSet::RemoveByKey(recordList, record, &ContinusPermissionRecord::IsEqualPermCode, retList);
90 }
91
RemoveCallerPid(std::set<ContinusPermissionRecord> & recordList,const ContinusPermissionRecord & record,std::vector<ContinusPermissionRecord> & retList)92 static void RemoveCallerPid(std::set<ContinusPermissionRecord>& recordList,
93 const ContinusPermissionRecord& record, std::vector<ContinusPermissionRecord>& retList)
94 {
95 return PermissionRecordSet::RemoveByKey(recordList, record, &ContinusPermissionRecord::IsEqualCallerPid, retList);
96 }
97
98 class PermissionRecordSetTest : public testing::Test {
99 public:
100 static void SetUpTestCase();
101 static void TearDownTestCase();
102 void SetUp();
103 void TearDown();
104 };
105
SetUpTestCase()106 void PermissionRecordSetTest::SetUpTestCase()
107 {
108 }
109
TearDownTestCase()110 void PermissionRecordSetTest::TearDownTestCase()
111 {
112 }
113
SetUp()114 void PermissionRecordSetTest::SetUp()
115 {
116 }
117
TearDown()118 void PermissionRecordSetTest::TearDown()
119 {
120 }
121
122 /**
123 * @tc.name: PermissionRecordSetTest0001
124 * @tc.desc: PermissionRecordSetTest set test.
125 * @tc.type: FUNC
126 * @tc.require:
127 */
128 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0001, TestSize.Level1)
129 {
130 int32_t recordList[][RECORD_ITEM_SIZE] = {
131 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
132 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
133 };
134 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
135 std::set<ContinusPermissionRecord> recordSet;
136 MakeRecordSet(recordList, setSize, recordSet);
137 EXPECT_EQ(recordSet.size(), 1);
138 }
139
140 /**
141 * @tc.name: PermissionRecordSetTest0002
142 * @tc.desc: PermissionRecordSetTest set test.
143 * @tc.type: FUNC
144 * @tc.require:
145 */
146 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0002, TestSize.Level1)
147 {
148 int32_t recordList[][RECORD_ITEM_SIZE] = {
149 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
150 { HAP_TOKEN_ID[0], OPCODE[0], INACTIVE, HAP_PID[0], CALLER_PID[0] },
151 };
152 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
153 std::set<ContinusPermissionRecord> recordSet;
154 MakeRecordSet(recordList, setSize, recordSet);
155 EXPECT_EQ(recordSet.size(), 1);
156 }
157
158 /**
159 * @tc.name: PermissionRecordSetTest0003
160 * @tc.desc: PermissionRecordSetTest set test.
161 * @tc.type: FUNC
162 * @tc.require:
163 */
164 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0003, TestSize.Level1)
165 {
166 int32_t recordList[][RECORD_ITEM_SIZE] = {
167 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
168 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[1] },
169 };
170 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
171 std::set<ContinusPermissionRecord> recordSet;
172 MakeRecordSet(recordList, setSize, recordSet);
173 EXPECT_EQ(recordSet.size(), 2);
174 }
175
176 /**
177 * @tc.name: PermissionRecordSetTest0004
178 * @tc.desc: PermissionRecordSetTest set test.
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0004, TestSize.Level1)
183 {
184 int32_t recordList[][RECORD_ITEM_SIZE] = {
185 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
186 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
187 };
188 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
189 std::set<ContinusPermissionRecord> recordSet;
190 MakeRecordSet(recordList, setSize, recordSet);
191 EXPECT_EQ(recordSet.size(), 2);
192 }
193
194 /**
195 * @tc.name: PermissionRecordSetTest0005
196 * @tc.desc: PermissionRecordSetTest set test.
197 * @tc.type: FUNC
198 * @tc.require:
199 */
200 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0005, TestSize.Level1)
201 {
202 int32_t recordList[][RECORD_ITEM_SIZE] = {
203 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
204 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
205 };
206 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
207 std::set<ContinusPermissionRecord> recordSet;
208 MakeRecordSet(recordList, setSize, recordSet);
209 EXPECT_EQ(recordSet.size(), 2);
210 }
211
212 /**
213 * @tc.name: PermissionRecordSetTest0006
214 * @tc.desc: PermissionRecordSetTest set test.
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0006, TestSize.Level1)
219 {
220 int32_t recordList[][RECORD_ITEM_SIZE] = {
221 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
222 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
223 };
224 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
225 std::set<ContinusPermissionRecord> recordSet;
226 MakeRecordSet(recordList, setSize, recordSet);
227 EXPECT_EQ(recordSet.size(), 2);
228 }
229
230 /**
231 * @tc.name: PermissionRecordSetTest0007
232 * @tc.desc: PermissionRecordSetTest set test.
233 * @tc.type: FUNC
234 * @tc.require:
235 */
236 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0007, TestSize.Level1)
237 {
238 int32_t recordList[][RECORD_ITEM_SIZE] = {
239 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
240 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
241 };
242 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
243 std::set<ContinusPermissionRecord> recordSet;
244 MakeRecordSet(recordList, setSize, recordSet);
245 EXPECT_EQ(recordSet.size(), 2);
246 }
247
248 /**
249 * @tc.name: PermissionRecordSetTest0008
250 * @tc.desc: PermissionRecordSetTest set test.
251 * @tc.type: FUNC
252 * @tc.require:
253 */
254 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0008, TestSize.Level1)
255 {
256 int32_t recordList[][RECORD_ITEM_SIZE] = {
257 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 0-3
258 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] }, // 1-5
259 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 2-2
260 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[1] }, // 3-4
261 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 4-0
262 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] }, // 5-1
263 };
264 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
265 std::set<ContinusPermissionRecord> recordSet;
266 MakeRecordSet(recordList, setSize, recordSet);
267 EXPECT_EQ(recordSet.size(), 6);
268 auto it = recordSet.begin();
269 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[4])));
270 ++it;
271 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[5])));
272 ++it;
273 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[2])));
274 ++it;
275 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[0])));
276 ++it;
277 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[3])));
278 ++it;
279 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[1])));
280 ++it;
281 EXPECT_EQ(it, recordSet.end());
282 }
283
284
285 /**
286 * @tc.name: PermissionRecordSetTest0009
287 * @tc.desc: PermissionRecordSetTest set test.
288 * @tc.type: FUNC
289 * @tc.require:
290 */
291 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0009, TestSize.Level1)
292 {
293 int32_t recordList[][RECORD_ITEM_SIZE] = {
294 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 0-0
295 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[1] }, // 1-1
296 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] }, // 2-2
297 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 3-3
298 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 4-4
299 };
300 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
301 std::set<ContinusPermissionRecord> recordSet;
302 MakeRecordSet(recordList, setSize, recordSet);
303 EXPECT_EQ(recordSet.size(), 5);
304 auto it = recordSet.begin();
305 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[0])));
306 ++it;
307 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[1])));
308 ++it;
309 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[2])));
310 ++it;
311 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[3])));
312 ++it;
313 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[4])));
314 ++it;
315 EXPECT_EQ(it, recordSet.end());
316 }
317
318 /**
319 * @tc.name: PermissionRecordSetTest0010
320 * @tc.desc: PermissionRecordSetTest set test.
321 * @tc.type: FUNC
322 * @tc.require:
323 */
324 HWTEST_F(PermissionRecordSetTest, PermissionRecordSetTest0010, TestSize.Level1)
325 {
326 int32_t recordList[][RECORD_ITEM_SIZE] = {
327 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 0-4
328 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 1-3
329 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] }, // 2-2
330 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[1] }, // 3-1
331 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] }, // 4-0
332 };
333 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
334 std::set<ContinusPermissionRecord> recordSet;
335 MakeRecordSet(recordList, setSize, recordSet);
336 EXPECT_EQ(recordSet.size(), 5);
337 auto it = recordSet.begin();
338 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[4])));
339 ++it;
340 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[3])));
341 ++it;
342 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[2])));
343 ++it;
344 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[1])));
345 ++it;
346 EXPECT_TRUE(it->IsEqualRecord(MakeRecord(recordList[0])));
347 ++it;
348 EXPECT_EQ(it, recordSet.end());
349 }
350
351 /**
352 * @tc.name: RemoveRecord0001
353 * @tc.desc: RemoveRecord test.
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(PermissionRecordSetTest, RemoveRecord0001, TestSize.Level1)
358 {
359 int32_t recordList[][RECORD_ITEM_SIZE] = {
360 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
361 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
362 };
363 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
364 std::set<ContinusPermissionRecord> recordSet;
365 MakeRecordSet(recordList, setSize, recordSet);
366 EXPECT_EQ(recordSet.size(), 2);
367 ContinusPermissionRecord record = {
368 .tokenId = HAP_TOKEN_ID[0],
369 .opCode = OPCODE[0],
370 .status = ACTIVE,
371 .pid = HAP_PID[0],
372 .callerPid = CALLER_PID[0],
373 };
374 std::vector<ContinusPermissionRecord> retList;
375 RemoveRecord(recordSet, record, retList);
376 EXPECT_EQ(recordSet.size(), 1);
377 EXPECT_EQ(retList.size(), 1);
378 std::vector<ContinusPermissionRecord> inactiveList;
379 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
380 EXPECT_EQ(inactiveList.size(), 1);
381 }
382
383 /**
384 * @tc.name: RemoveRecord0002
385 * @tc.desc: RemoveRecord test.
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(PermissionRecordSetTest, RemoveRecord0002, TestSize.Level1)
390 {
391 int32_t recordList[][RECORD_ITEM_SIZE] = {
392 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
393 { HAP_TOKEN_ID[0], OPCODE[0], INACTIVE, HAP_PID[0], CALLER_PID[0] },
394 };
395 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
396 std::set<ContinusPermissionRecord> recordSet;
397 MakeRecordSet(recordList, setSize, recordSet);
398 EXPECT_EQ(recordSet.size(), 2);
399 ContinusPermissionRecord record = {
400 .tokenId = HAP_TOKEN_ID[0],
401 .opCode = OPCODE[0],
402 .status = ACTIVE,
403 .pid = HAP_PID[0],
404 .callerPid = CALLER_PID[0],
405 };
406 std::vector<ContinusPermissionRecord> retList;
407 RemoveRecord(recordSet, record, retList);
408 EXPECT_EQ(recordSet.size(), 1);
409 EXPECT_EQ(retList.size(), 1);
410 std::vector<ContinusPermissionRecord> inactiveList;
411 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
412 EXPECT_EQ(inactiveList.size(), 0);
413 }
414
415 /**
416 * @tc.name: RemoveRecord0003
417 * @tc.desc: RemoveRecord test.
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(PermissionRecordSetTest, RemoveRecord0003, TestSize.Level1)
422 {
423 int32_t recordList[][RECORD_ITEM_SIZE] = {
424 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
425 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
426 };
427 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
428 std::set<ContinusPermissionRecord> recordSet;
429 MakeRecordSet(recordList, setSize, recordSet);
430 EXPECT_EQ(recordSet.size(), 2);
431 ContinusPermissionRecord record = {
432 .tokenId = HAP_TOKEN_ID[0],
433 .opCode = OPCODE[0],
434 .status = ACTIVE,
435 .pid = HAP_PID[0],
436 .callerPid = CALLER_PID[0],
437 };
438 std::vector<ContinusPermissionRecord> retList;
439 RemoveRecord(recordSet, record, retList);
440 EXPECT_EQ(recordSet.size(), 2);
441 EXPECT_EQ(retList.size(), 0);
442 std::vector<ContinusPermissionRecord> inactiveList;
443 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
444 EXPECT_EQ(inactiveList.size(), 0);
445 }
446
447 /**
448 * @tc.name: RemoveRecord0005
449 * @tc.desc: RemoveRecord test.
450 * @tc.type: FUNC
451 * @tc.require:
452 */
453 HWTEST_F(PermissionRecordSetTest, RemoveRecord0005, TestSize.Level1)
454 {
455 int32_t recordList[][RECORD_ITEM_SIZE] = {
456 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
457 { HAP_TOKEN_ID[0], OPCODE[0], INACTIVE, HAP_PID[1], CALLER_PID[0] },
458 };
459 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
460 std::set<ContinusPermissionRecord> recordSet;
461 MakeRecordSet(recordList, setSize, recordSet);
462 EXPECT_EQ(recordSet.size(), 2);
463 ContinusPermissionRecord record = {
464 .tokenId = HAP_TOKEN_ID[0],
465 .opCode = OPCODE[0],
466 .status = ACTIVE,
467 .pid = HAP_PID[0],
468 .callerPid = CALLER_PID[0],
469 };
470 std::vector<ContinusPermissionRecord> retList;
471 RemoveRecord(recordSet, record, retList);
472 EXPECT_EQ(recordSet.size(), 1);
473 EXPECT_EQ(retList.size(), 1);
474 std::vector<ContinusPermissionRecord> inactiveList;
475 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
476 EXPECT_EQ(inactiveList.size(), 1);
477 }
478
479 /**
480 * @tc.name: RemoveTokenId0001
481 * @tc.desc: RemoveTokenId test.
482 * @tc.type: FUNC
483 * @tc.require:
484 */
485 HWTEST_F(PermissionRecordSetTest, RemoveTokenId0001, TestSize.Level1)
486 {
487 int32_t recordList[][RECORD_ITEM_SIZE] = {
488 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
489 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
490 };
491 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
492 std::set<ContinusPermissionRecord> recordSet;
493 MakeRecordSet(recordList, setSize, recordSet);
494 EXPECT_EQ(recordSet.size(), 2);
495 ContinusPermissionRecord record = {
496 .tokenId = HAP_TOKEN_ID[0],
497 .opCode = OPCODE[1],
498 .status = ACTIVE,
499 .pid = HAP_PID[0],
500 .callerPid = CALLER_PID[0],
501 };
502 std::vector<ContinusPermissionRecord> retList;
503 RemoveTokenId(recordSet, record, retList);
504 EXPECT_EQ(recordSet.size(), 1);
505 EXPECT_EQ(retList.size(), 1);
506 std::vector<ContinusPermissionRecord> inactiveList;
507 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
508 EXPECT_EQ(inactiveList.size(), 1);
509 }
510
511 /**
512 * @tc.name: RemoveTokenId0002
513 * @tc.desc: RemoveTokenId test.
514 * @tc.type: FUNC
515 * @tc.require:
516 */
517 HWTEST_F(PermissionRecordSetTest, RemoveTokenId0002, TestSize.Level1)
518 {
519 int32_t recordList[][RECORD_ITEM_SIZE] = {
520 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
521 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
522 };
523 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
524 std::set<ContinusPermissionRecord> recordSet;
525 MakeRecordSet(recordList, setSize, recordSet);
526 EXPECT_EQ(recordSet.size(), 2);
527 ContinusPermissionRecord record = {
528 .tokenId = HAP_TOKEN_ID[0],
529 .opCode = OPCODE[1],
530 .status = ACTIVE,
531 .pid = HAP_PID[0],
532 .callerPid = CALLER_PID[0],
533 };
534 std::vector<ContinusPermissionRecord> retList;
535 RemoveTokenId(recordSet, record, retList);
536 EXPECT_EQ(recordSet.size(), 0);
537 EXPECT_EQ(retList.size(), 2);
538 std::vector<ContinusPermissionRecord> inactiveList;
539 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
540 EXPECT_EQ(inactiveList.size(), 1);
541 }
542
543 /**
544 * @tc.name: RemoveTokenId0003
545 * @tc.desc: RemoveRecord test.
546 * @tc.type: FUNC
547 * @tc.require:
548 */
549 HWTEST_F(PermissionRecordSetTest, RemoveTokenId0003, TestSize.Level1)
550 {
551 int32_t recordList[][RECORD_ITEM_SIZE] = {
552 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
553 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
554 };
555 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
556 std::set<ContinusPermissionRecord> recordSet;
557 MakeRecordSet(recordList, setSize, recordSet);
558 EXPECT_EQ(recordSet.size(), 2);
559 ContinusPermissionRecord record = {
560 .tokenId = HAP_TOKEN_ID[0],
561 .opCode = OPCODE[1],
562 .status = ACTIVE,
563 .pid = HAP_PID[0],
564 .callerPid = CALLER_PID[0],
565 };
566 std::vector<ContinusPermissionRecord> retList;
567 RemoveTokenId(recordSet, record, retList);
568 EXPECT_EQ(recordSet.size(), 2);
569 EXPECT_EQ(retList.size(), 0);
570 std::vector<ContinusPermissionRecord> inactiveList;
571 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
572 EXPECT_EQ(inactiveList.size(), 0);
573 }
574
575 /**
576 * @tc.name: RemoveTokenIdAndPid0001
577 * @tc.desc: RemoveTokenIdAndPid test.
578 * @tc.type: FUNC
579 * @tc.require:
580 */
581 HWTEST_F(PermissionRecordSetTest, RemoveTokenIdAndPid0001, TestSize.Level1)
582 {
583 int32_t recordList[][RECORD_ITEM_SIZE] = {
584 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
585 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
586 };
587 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
588 std::set<ContinusPermissionRecord> recordSet;
589 MakeRecordSet(recordList, setSize, recordSet);
590 EXPECT_EQ(recordSet.size(), 2);
591 ContinusPermissionRecord record = {
592 .tokenId = HAP_TOKEN_ID[0],
593 .opCode = OPCODE[1],
594 .status = ACTIVE,
595 .pid = HAP_PID[0],
596 .callerPid = CALLER_PID[0],
597 };
598 std::vector<ContinusPermissionRecord> retList;
599 RemoveTokenIdAndPid(recordSet, record, retList);
600 EXPECT_EQ(recordSet.size(), 0);
601 EXPECT_EQ(retList.size(), 2);
602 std::vector<ContinusPermissionRecord> inactiveList;
603 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
604 EXPECT_EQ(inactiveList.size(), 2);
605 }
606
607 /**
608 * @tc.name: RemoveTokenIdAndPid0002
609 * @tc.desc: RemoveTokenIdAndPid test.
610 * @tc.type: FUNC
611 * @tc.require:
612 */
613 HWTEST_F(PermissionRecordSetTest, RemoveTokenIdAndPid0002, TestSize.Level1)
614 {
615 int32_t recordList[][RECORD_ITEM_SIZE] = {
616 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
617 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
618 };
619 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
620 std::set<ContinusPermissionRecord> recordSet;
621 MakeRecordSet(recordList, setSize, recordSet);
622 EXPECT_EQ(recordSet.size(), 2);
623 ContinusPermissionRecord record = {
624 .tokenId = HAP_TOKEN_ID[0],
625 .opCode = OPCODE[1],
626 .status = ACTIVE,
627 .pid = HAP_PID[0],
628 .callerPid = CALLER_PID[0],
629 };
630 std::vector<ContinusPermissionRecord> retList;
631 RemoveTokenIdAndPid(recordSet, record, retList);
632 EXPECT_EQ(recordSet.size(), 1);
633 EXPECT_EQ(retList.size(), 1);
634 std::vector<ContinusPermissionRecord> inactiveList;
635 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
636 EXPECT_EQ(inactiveList.size(), 1);
637 }
638
639 /**
640 * @tc.name: RemoveTokenIdAndPid0003
641 * @tc.desc: RemoveTokenIdAndPid test.
642 * @tc.type: FUNC
643 * @tc.require:
644 */
645 HWTEST_F(PermissionRecordSetTest, RemoveTokenIdAndPid0003, TestSize.Level1)
646 {
647 int32_t recordList[][RECORD_ITEM_SIZE] = {
648 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
649 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
650 };
651 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
652 std::set<ContinusPermissionRecord> recordSet;
653 MakeRecordSet(recordList, setSize, recordSet);
654 EXPECT_EQ(recordSet.size(), 2);
655 ContinusPermissionRecord record = {
656 .tokenId = HAP_TOKEN_ID[0],
657 .opCode = OPCODE[1],
658 .status = ACTIVE,
659 .pid = HAP_PID[0],
660 .callerPid = CALLER_PID[0],
661 };
662 std::vector<ContinusPermissionRecord> retList;
663 RemoveTokenIdAndPid(recordSet, record, retList);
664 EXPECT_EQ(recordSet.size(), 2);
665 EXPECT_EQ(retList.size(), 0);
666 std::vector<ContinusPermissionRecord> inactiveList;
667 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
668 EXPECT_EQ(inactiveList.size(), 0);
669 }
670
671 /**
672 * @tc.name: RemoveTokenIdAndPid0004
673 * @tc.desc: RemoveTokenIdAndPid test.
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(PermissionRecordSetTest, RemoveTokenIdAndPid0004, TestSize.Level1)
678 {
679 int32_t recordList[][RECORD_ITEM_SIZE] = {
680 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
681 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
682 };
683 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
684 std::set<ContinusPermissionRecord> recordSet;
685 MakeRecordSet(recordList, setSize, recordSet);
686 EXPECT_EQ(recordSet.size(), 2);
687 ContinusPermissionRecord record = {
688 .tokenId = HAP_TOKEN_ID[0],
689 .opCode = OPCODE[1],
690 .status = ACTIVE,
691 .pid = HAP_PID[0],
692 .callerPid = CALLER_PID[0],
693 };
694 std::vector<ContinusPermissionRecord> retList;
695 RemoveTokenIdAndPid(recordSet, record, retList);
696 EXPECT_EQ(recordSet.size(), 1);
697 EXPECT_EQ(retList.size(), 1);
698 std::vector<ContinusPermissionRecord> inactiveList;
699 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
700 EXPECT_EQ(inactiveList.size(), 0);
701 }
702
703 /**
704 * @tc.name: RemoveTokenIdAndPid0005
705 * @tc.desc: RemoveTokenIdAndPid test.
706 * @tc.type: FUNC
707 * @tc.require:
708 */
709 HWTEST_F(PermissionRecordSetTest, RemoveTokenIdAndPid0005, TestSize.Level1)
710 {
711 int32_t recordList[][RECORD_ITEM_SIZE] = {
712 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
713 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, -1, CALLER_PID[1] },
714 };
715 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
716 std::set<ContinusPermissionRecord> recordSet;
717 MakeRecordSet(recordList, setSize, recordSet);
718 EXPECT_EQ(recordSet.size(), 2);
719 ContinusPermissionRecord record = {
720 .tokenId = HAP_TOKEN_ID[0],
721 .opCode = OPCODE[1],
722 .status = ACTIVE,
723 .pid = HAP_PID[0],
724 .callerPid = CALLER_PID[0],
725 };
726 std::vector<ContinusPermissionRecord> retList;
727 RemoveTokenIdAndPid(recordSet, record, retList);
728 EXPECT_EQ(recordSet.size(), 1);
729 EXPECT_EQ(retList.size(), 1);
730 std::vector<ContinusPermissionRecord> inactiveList;
731 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
732 EXPECT_EQ(inactiveList.size(), 0);
733 }
734
735 /**
736 * @tc.name: RemovePermCode0001
737 * @tc.desc: RemovePermCode test.
738 * @tc.type: FUNC
739 * @tc.require:
740 */
741 HWTEST_F(PermissionRecordSetTest, RemovePermCode0001, TestSize.Level1)
742 {
743 int32_t recordList[][RECORD_ITEM_SIZE] = {
744 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
745 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
746 };
747 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
748 std::set<ContinusPermissionRecord> recordSet;
749 MakeRecordSet(recordList, setSize, recordSet);
750 EXPECT_EQ(recordSet.size(), 2);
751 ContinusPermissionRecord record = {
752 .tokenId = HAP_TOKEN_ID[0],
753 .opCode = OPCODE[0],
754 .status = ACTIVE,
755 .pid = HAP_PID[0],
756 .callerPid = CALLER_PID[0],
757 };
758 std::vector<ContinusPermissionRecord> retList;
759 RemovePermCode(recordSet, record, retList);
760 EXPECT_EQ(recordSet.size(), 0);
761 EXPECT_EQ(retList.size(), 2);
762 std::vector<ContinusPermissionRecord> inactiveList;
763 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
764 EXPECT_EQ(inactiveList.size(), 1);
765 }
766
767 /**
768 * @tc.name: RemovePermCode0002
769 * @tc.desc: RemovePermCode test.
770 * @tc.type: FUNC
771 * @tc.require:
772 */
773 HWTEST_F(PermissionRecordSetTest, RemovePermCode0002, TestSize.Level1)
774 {
775 int32_t recordList[][RECORD_ITEM_SIZE] = {
776 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
777 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
778 };
779 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
780 std::set<ContinusPermissionRecord> recordSet;
781 MakeRecordSet(recordList, setSize, recordSet);
782 EXPECT_EQ(recordSet.size(), 2);
783 ContinusPermissionRecord record = {
784 .tokenId = HAP_TOKEN_ID[0],
785 .opCode = OPCODE[0],
786 .status = ACTIVE,
787 .pid = HAP_PID[0],
788 .callerPid = CALLER_PID[0],
789 };
790 std::vector<ContinusPermissionRecord> retList;
791 RemovePermCode(recordSet, record, retList);
792 EXPECT_EQ(recordSet.size(), 1);
793 EXPECT_EQ(retList.size(), 1);
794 std::vector<ContinusPermissionRecord> inactiveList;
795 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
796 EXPECT_EQ(inactiveList.size(), 1);
797 }
798
799 /**
800 * @tc.name: RemovePermCode0003
801 * @tc.desc: RemovePermCode test.
802 * @tc.type: FUNC
803 * @tc.require:
804 */
805 HWTEST_F(PermissionRecordSetTest, RemovePermCode0003, TestSize.Level1)
806 {
807 int32_t recordList[][RECORD_ITEM_SIZE] = {
808 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
809 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
810 };
811 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
812 std::set<ContinusPermissionRecord> recordSet;
813 MakeRecordSet(recordList, setSize, recordSet);
814 EXPECT_EQ(recordSet.size(), 2);
815 ContinusPermissionRecord record = {
816 .tokenId = HAP_TOKEN_ID[0],
817 .opCode = OPCODE[0],
818 .status = ACTIVE,
819 .pid = HAP_PID[0],
820 .callerPid = CALLER_PID[0],
821 };
822 std::vector<ContinusPermissionRecord> retList;
823 RemovePermCode(recordSet, record, retList);
824 EXPECT_EQ(recordSet.size(), 2);
825 EXPECT_EQ(retList.size(), 0);
826 std::vector<ContinusPermissionRecord> inactiveList;
827 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
828 EXPECT_EQ(inactiveList.size(), 0);
829 }
830
831 /**
832 * @tc.name: RemovePermCode0004
833 * @tc.desc: RemovePermCode test.
834 * @tc.type: FUNC
835 * @tc.require:
836 */
837 HWTEST_F(PermissionRecordSetTest, RemovePermCode0004, TestSize.Level1)
838 {
839 int32_t recordList[][RECORD_ITEM_SIZE] = {
840 { HAP_TOKEN_ID[0], OPCODE[0], INACTIVE, HAP_PID[0], CALLER_PID[0] },
841 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
842 };
843 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
844 std::set<ContinusPermissionRecord> recordSet;
845 MakeRecordSet(recordList, setSize, recordSet);
846 EXPECT_EQ(recordSet.size(), 2);
847 ContinusPermissionRecord record = {
848 .tokenId = HAP_TOKEN_ID[0],
849 .opCode = OPCODE[0],
850 .status = ACTIVE,
851 .pid = HAP_PID[0],
852 .callerPid = CALLER_PID[0],
853 };
854 std::vector<ContinusPermissionRecord> retList;
855 RemovePermCode(recordSet, record, retList);
856 EXPECT_EQ(recordSet.size(), 1);
857 EXPECT_EQ(retList.size(), 1);
858 std::vector<ContinusPermissionRecord> inactiveList;
859 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
860 EXPECT_EQ(inactiveList.size(), 1);
861 }
862
863 /**
864 * @tc.name: RemoveCallerPid0001
865 * @tc.desc: RemoveCallerPid test.
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 HWTEST_F(PermissionRecordSetTest, RemoveCallerPid0001, TestSize.Level1)
870 {
871 int32_t recordList[][RECORD_ITEM_SIZE] = {
872 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
873 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
874 };
875 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
876 std::set<ContinusPermissionRecord> recordSet;
877 MakeRecordSet(recordList, setSize, recordSet);
878 EXPECT_EQ(recordSet.size(), 2);
879 ContinusPermissionRecord record = {
880 .tokenId = HAP_TOKEN_ID[0],
881 .opCode = OPCODE[0],
882 .status = ACTIVE,
883 .pid = HAP_PID[0],
884 .callerPid = CALLER_PID[0],
885 };
886 std::vector<ContinusPermissionRecord> retList;
887 RemoveCallerPid(recordSet, record, retList);
888 EXPECT_EQ(recordSet.size(), 0);
889 EXPECT_EQ(retList.size(), 2);
890 std::vector<ContinusPermissionRecord> inactiveList;
891 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
892 EXPECT_EQ(inactiveList.size(), 1);
893 }
894
895 /**
896 * @tc.name: RemoveCallerPid0002
897 * @tc.desc: RemoveCallerPid test.
898 * @tc.type: FUNC
899 * @tc.require:
900 */
901 HWTEST_F(PermissionRecordSetTest, RemoveCallerPid0002, TestSize.Level1)
902 {
903 int32_t recordList[][RECORD_ITEM_SIZE] = {
904 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
905 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
906 };
907 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
908 std::set<ContinusPermissionRecord> recordSet;
909 MakeRecordSet(recordList, setSize, recordSet);
910 EXPECT_EQ(recordSet.size(), 2);
911 ContinusPermissionRecord record = {
912 .tokenId = HAP_TOKEN_ID[0],
913 .opCode = OPCODE[0],
914 .status = ACTIVE,
915 .pid = HAP_PID[0],
916 .callerPid = CALLER_PID[0],
917 };
918 std::vector<ContinusPermissionRecord> retList;
919 RemoveCallerPid(recordSet, record, retList);
920 EXPECT_EQ(recordSet.size(), 0);
921 EXPECT_EQ(retList.size(), 2);
922 std::vector<ContinusPermissionRecord> inactiveList;
923 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
924 EXPECT_EQ(inactiveList.size(), 2);
925 }
926
927 /**
928 * @tc.name: RemoveCallerPid0003
929 * @tc.desc: RemoveCallerPid test.
930 * @tc.type: FUNC
931 * @tc.require:
932 */
933 HWTEST_F(PermissionRecordSetTest, RemoveCallerPid0003, TestSize.Level1)
934 {
935 int32_t recordList[][RECORD_ITEM_SIZE] = {
936 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
937 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[1] },
938 };
939 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
940 std::set<ContinusPermissionRecord> recordSet;
941 MakeRecordSet(recordList, setSize, recordSet);
942 EXPECT_EQ(recordSet.size(), 2);
943 ContinusPermissionRecord record = {
944 .tokenId = HAP_TOKEN_ID[0],
945 .opCode = OPCODE[0],
946 .status = ACTIVE,
947 .pid = HAP_PID[0],
948 .callerPid = CALLER_PID[0],
949 };
950 std::vector<ContinusPermissionRecord> retList;
951 RemoveCallerPid(recordSet, record, retList);
952 EXPECT_EQ(recordSet.size(), 1);
953 EXPECT_EQ(retList.size(), 1);
954 std::vector<ContinusPermissionRecord> inactiveList;
955 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
956 EXPECT_EQ(inactiveList.size(), 1);
957 }
958
959 /**
960 * @tc.name: RemoveCallerPid0004
961 * @tc.desc: RemoveCallerPid test.
962 * @tc.type: FUNC
963 * @tc.require:
964 */
965 HWTEST_F(PermissionRecordSetTest, RemoveCallerPid0004, TestSize.Level1)
966 {
967 int32_t recordList[][RECORD_ITEM_SIZE] = {
968 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[1] },
969 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[1] },
970 };
971 int32_t setSize = sizeof(recordList) / sizeof(recordList[0]);
972 std::set<ContinusPermissionRecord> recordSet;
973 MakeRecordSet(recordList, setSize, recordSet);
974 EXPECT_EQ(recordSet.size(), 2);
975 ContinusPermissionRecord record = {
976 .tokenId = HAP_TOKEN_ID[0],
977 .opCode = OPCODE[0],
978 .status = ACTIVE,
979 .pid = HAP_PID[0],
980 .callerPid = CALLER_PID[0],
981 };
982 std::vector<ContinusPermissionRecord> retList;
983 RemoveCallerPid(recordSet, record, retList);
984 EXPECT_EQ(recordSet.size(), 2);
985 EXPECT_EQ(retList.size(), 0);
986 std::vector<ContinusPermissionRecord> inactiveList;
987 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, retList, inactiveList);
988 EXPECT_EQ(inactiveList.size(), 0);
989 }
990
991 /**
992 * @tc.name: GetUnusedCameraRecords0001
993 * @tc.desc: GetUnusedCameraRecords test.
994 * @tc.type: FUNC
995 * @tc.require:
996 */
997 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0001, TestSize.Level1)
998 {
999 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1000 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1001 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1002 };
1003 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1004 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1005 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1006 };
1007 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1008 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1009 std::set<ContinusPermissionRecord> recordSet;
1010 MakeRecordSet(recordArray1, size1, recordSet);
1011 std::vector<ContinusPermissionRecord> recordList;
1012 MakeRecordList(recordArray2, size2, recordList);
1013 std::vector<ContinusPermissionRecord> inactiveList;
1014 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1015 EXPECT_EQ(inactiveList.size(), 0);
1016 }
1017
1018 /**
1019 * @tc.name: GetUnusedCameraRecords0002
1020 * @tc.desc: GetUnusedCameraRecords test.
1021 * @tc.type: FUNC
1022 * @tc.require:
1023 */
1024 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0002, TestSize.Level1)
1025 {
1026 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1027 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1028 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1029 };
1030 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1031 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1032 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1033 };
1034 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1035 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1036 std::set<ContinusPermissionRecord> recordSet;
1037 MakeRecordSet(recordArray1, size1, recordSet);
1038 std::vector<ContinusPermissionRecord> recordList;
1039 MakeRecordList(recordArray2, size2, recordList);
1040 std::vector<ContinusPermissionRecord> inactiveList;
1041 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1042 EXPECT_EQ(inactiveList.size(), 1);
1043 }
1044
1045 /**
1046 * @tc.name: GetUnusedCameraRecords0003
1047 * @tc.desc: GetUnusedCameraRecords test.
1048 * @tc.type: FUNC
1049 * @tc.require:
1050 */
1051 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0003, TestSize.Level1)
1052 {
1053 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1054 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1055 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1056 };
1057 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1058 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1059 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1060 };
1061 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1062 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1063 std::set<ContinusPermissionRecord> recordSet;
1064 MakeRecordSet(recordArray1, size1, recordSet);
1065 std::vector<ContinusPermissionRecord> recordList;
1066 MakeRecordList(recordArray2, size2, recordList);
1067 std::vector<ContinusPermissionRecord> inactiveList;
1068 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1069 EXPECT_EQ(inactiveList.size(), 1);
1070 }
1071
1072 /**
1073 * @tc.name: GetUnusedCameraRecords0004
1074 * @tc.desc: GetUnusedCameraRecords test.
1075 * @tc.type: FUNC
1076 * @tc.require:
1077 */
1078 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0004, TestSize.Level1)
1079 {
1080 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1081 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1082 { HAP_TOKEN_ID[1], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1083 };
1084 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1085 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1086 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1087 };
1088 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1089 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1090 std::set<ContinusPermissionRecord> recordSet;
1091 MakeRecordSet(recordArray1, size1, recordSet);
1092 std::vector<ContinusPermissionRecord> recordList;
1093 MakeRecordList(recordArray2, size2, recordList);
1094 std::vector<ContinusPermissionRecord> inactiveList;
1095 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1096 EXPECT_EQ(inactiveList.size(), 1);
1097 }
1098
1099 /**
1100 * @tc.name: GetUnusedCameraRecords0005
1101 * @tc.desc: GetUnusedCameraRecords test.
1102 * @tc.type: FUNC
1103 * @tc.require:
1104 */
1105 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0005, TestSize.Level1)
1106 {
1107 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1108 { HAP_TOKEN_ID[1], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1109 };
1110 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1111 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1112 };
1113 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1114 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1115 std::set<ContinusPermissionRecord> recordSet;
1116 MakeRecordSet(recordArray1, size1, recordSet);
1117 std::vector<ContinusPermissionRecord> recordList;
1118 MakeRecordList(recordArray2, size2, recordList);
1119 std::vector<ContinusPermissionRecord> inactiveList;
1120 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1121 EXPECT_EQ(inactiveList.size(), 1);
1122 }
1123
1124 /**
1125 * @tc.name: GetUnusedCameraRecords0006
1126 * @tc.desc: GetUnusedCameraRecords test.
1127 * @tc.type: FUNC
1128 * @tc.require:
1129 */
1130 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0006, TestSize.Level1)
1131 {
1132 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1133 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1134 };
1135 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1136 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1137 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[1] },
1138 };
1139 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1140 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1141 std::set<ContinusPermissionRecord> recordSet;
1142 MakeRecordSet(recordArray1, size1, recordSet);
1143 std::vector<ContinusPermissionRecord> recordList;
1144 MakeRecordList(recordArray2, size2, recordList);
1145 std::vector<ContinusPermissionRecord> inactiveList;
1146 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1147 EXPECT_EQ(inactiveList.size(), 1);
1148 }
1149
1150 /**
1151 * @tc.name: GetUnusedCameraRecords0007
1152 * @tc.desc: GetUnusedCameraRecords test.
1153 * @tc.type: FUNC
1154 * @tc.require:
1155 */
1156 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0007, TestSize.Level1)
1157 {
1158 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1159 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1160 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[1] },
1161 };
1162 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1163 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1164 };
1165 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1166 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1167 std::set<ContinusPermissionRecord> recordSet;
1168 MakeRecordSet(recordArray1, size1, recordSet);
1169 std::vector<ContinusPermissionRecord> recordList;
1170 MakeRecordList(recordArray2, size2, recordList);
1171 std::vector<ContinusPermissionRecord> inactiveList;
1172 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1173 EXPECT_EQ(inactiveList.size(), 0);
1174 }
1175
1176 /**
1177 * @tc.name: GetUnusedCameraRecords0008
1178 * @tc.desc: GetUnusedCameraRecords test.
1179 * @tc.type: FUNC
1180 * @tc.require:
1181 */
1182 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0008, TestSize.Level1)
1183 {
1184 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1185 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1186 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[1] },
1187 };
1188 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1189 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1190 };
1191 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1192 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1193 std::set<ContinusPermissionRecord> recordSet;
1194 MakeRecordSet(recordArray1, size1, recordSet);
1195 std::vector<ContinusPermissionRecord> recordList;
1196 MakeRecordList(recordArray2, size2, recordList);
1197 std::vector<ContinusPermissionRecord> inactiveList;
1198 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1199 EXPECT_EQ(inactiveList.size(), 1);
1200 }
1201
1202 /**
1203 * @tc.name: GetUnusedCameraRecords0009
1204 * @tc.desc: GetUnusedCameraRecords test.
1205 * @tc.type: FUNC
1206 * @tc.require:
1207 */
1208 HWTEST_F(PermissionRecordSetTest, GetUnusedCameraRecords0009, TestSize.Level1)
1209 {
1210 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1211 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, -1, CALLER_PID[0] },
1212 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[1] },
1213 };
1214 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1215 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1216 };
1217 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1218 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1219 std::set<ContinusPermissionRecord> recordSet;
1220 MakeRecordSet(recordArray1, size1, recordSet);
1221 std::vector<ContinusPermissionRecord> recordList;
1222 MakeRecordList(recordArray2, size2, recordList);
1223 std::vector<ContinusPermissionRecord> inactiveList;
1224 PermissionRecordSet::GetUnusedCameraRecords(recordSet, recordList, inactiveList);
1225 EXPECT_EQ(inactiveList.size(), 0);
1226 }
1227
1228 /**
1229 * @tc.name: GetInActiveUniqueRecord0001
1230 * @tc.desc: GetInActiveUniqueRecord test.
1231 * @tc.type: FUNC
1232 * @tc.require:
1233 */
1234 HWTEST_F(PermissionRecordSetTest, GetInActiveUniqueRecord0001, TestSize.Level1)
1235 {
1236 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1237 { HAP_TOKEN_ID[0], OPCODE[1], INACTIVE, HAP_PID[0], CALLER_PID[0] },
1238 { HAP_TOKEN_ID[1], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[1] },
1239 };
1240 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1241 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1242 { HAP_TOKEN_ID[1], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1243 };
1244 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1245 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1246 std::set<ContinusPermissionRecord> recordSet;
1247 MakeRecordSet(recordArray1, size1, recordSet);
1248 std::vector<ContinusPermissionRecord> recordList;
1249 MakeRecordList(recordArray2, size2, recordList);
1250 std::vector<ContinusPermissionRecord> inactiveList;
1251 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, recordList, inactiveList);
1252 EXPECT_EQ(inactiveList.size(), 1);
1253 }
1254
1255 /**
1256 * @tc.name: GetInActiveUniqueRecord0002
1257 * @tc.desc: GetInActiveUniqueRecord test.
1258 * @tc.type: FUNC
1259 * @tc.require:
1260 */
1261 HWTEST_F(PermissionRecordSetTest, GetInActiveUniqueRecord0002, TestSize.Level1)
1262 {
1263 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1264 { HAP_TOKEN_ID[0], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1265 };
1266 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1267 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1268 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1269 };
1270 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1271 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1272 std::set<ContinusPermissionRecord> recordSet;
1273 MakeRecordSet(recordArray1, size1, recordSet);
1274 std::vector<ContinusPermissionRecord> recordList;
1275 MakeRecordList(recordArray2, size2, recordList);
1276 std::vector<ContinusPermissionRecord> inactiveList;
1277 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, recordList, inactiveList);
1278 EXPECT_EQ(inactiveList.size(), 1);
1279 }
1280
1281 /**
1282 * @tc.name: GetInActiveUniqueRecord0003
1283 * @tc.desc: GetInActiveUniqueRecord test.
1284 * @tc.type: FUNC
1285 * @tc.require:
1286 */
1287 HWTEST_F(PermissionRecordSetTest, GetInActiveUniqueRecord0003, TestSize.Level1)
1288 {
1289 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1290 { HAP_TOKEN_ID[1], OPCODE[0], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1291 };
1292 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1293 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1294 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1295 };
1296 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1297 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1298 std::set<ContinusPermissionRecord> recordSet;
1299 MakeRecordSet(recordArray1, size1, recordSet);
1300 std::vector<ContinusPermissionRecord> recordList;
1301 MakeRecordList(recordArray2, size2, recordList);
1302 std::vector<ContinusPermissionRecord> inactiveList;
1303 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, recordList, inactiveList);
1304 EXPECT_EQ(inactiveList.size(), 1);
1305 }
1306
1307 /**
1308 * @tc.name: GetInActiveUniqueRecord0004
1309 * @tc.desc: GetInActiveUniqueRecord test.
1310 * @tc.type: FUNC
1311 * @tc.require:
1312 */
1313 HWTEST_F(PermissionRecordSetTest, GetInActiveUniqueRecord0004, TestSize.Level1)
1314 {
1315 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1316 { HAP_TOKEN_ID[0], OPCODE[1], INACTIVE, HAP_PID[1], CALLER_PID[0] },
1317 };
1318 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1319 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1320 };
1321 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1322 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1323 std::set<ContinusPermissionRecord> recordSet;
1324 MakeRecordSet(recordArray1, size1, recordSet);
1325 std::vector<ContinusPermissionRecord> recordList;
1326 MakeRecordList(recordArray2, size2, recordList);
1327 std::vector<ContinusPermissionRecord> inactiveList;
1328 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, recordList, inactiveList);
1329 EXPECT_EQ(inactiveList.size(), 1);
1330 }
1331
1332 /**
1333 * @tc.name: GetInActiveUniqueRecord0005
1334 * @tc.desc: GetInActiveUniqueRecord test.
1335 * @tc.type: FUNC
1336 * @tc.require:
1337 */
1338 HWTEST_F(PermissionRecordSetTest, GetInActiveUniqueRecord0005, TestSize.Level1)
1339 {
1340 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1341 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[0] },
1342 };
1343 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1344 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1345 };
1346 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1347 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1348 std::set<ContinusPermissionRecord> recordSet;
1349 MakeRecordSet(recordArray1, size1, recordSet);
1350 std::vector<ContinusPermissionRecord> recordList;
1351 MakeRecordList(recordArray2, size2, recordList);
1352 std::vector<ContinusPermissionRecord> inactiveList;
1353 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, recordList, inactiveList);
1354 EXPECT_EQ(inactiveList.size(), 0);
1355 }
1356
1357 /**
1358 * @tc.name: GetInActiveUniqueRecord0006
1359 * @tc.desc: GetInActiveUniqueRecord test.
1360 * @tc.type: FUNC
1361 * @tc.require:
1362 */
1363 HWTEST_F(PermissionRecordSetTest, GetInActiveUniqueRecord0006, TestSize.Level1)
1364 {
1365 int32_t recordArray1[][RECORD_ITEM_SIZE] = {
1366 { HAP_TOKEN_ID[0], OPCODE[1], INACTIVE, HAP_PID[1], CALLER_PID[0] },
1367 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[1], CALLER_PID[1] },
1368 };
1369 int32_t recordArray2[][RECORD_ITEM_SIZE] = {
1370 { HAP_TOKEN_ID[0], OPCODE[1], ACTIVE, HAP_PID[0], CALLER_PID[0] },
1371 };
1372 int32_t size1 = sizeof(recordArray1) / sizeof(recordArray1[0]);
1373 int32_t size2 = sizeof(recordArray2) / sizeof(recordArray1[0]);
1374 std::set<ContinusPermissionRecord> recordSet;
1375 MakeRecordSet(recordArray1, size1, recordSet);
1376 std::vector<ContinusPermissionRecord> recordList;
1377 MakeRecordList(recordArray2, size2, recordList);
1378 std::vector<ContinusPermissionRecord> inactiveList;
1379 PermissionRecordSet::GetInActiveUniqueRecord(recordSet, recordList, inactiveList);
1380 EXPECT_EQ(inactiveList.size(), 0);
1381 }
1382 }
1383 }
1384 }