1 /*
2 * Copyright (c) 2023-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 <sys/stat.h>
18 #include <sys/types.h>
19 #include <string>
20 #include <vector>
21 #include <iostream>
22
23 #define private public
24 #define protected public
25 #include "profile_utils.h"
26 #include "trust_profile_manager.h"
27 #include "distributed_device_profile_constants.h"
28 #include "distributed_device_profile_log.h"
29 #include "distributed_device_profile_errors.h"
30 #include "rdb_open_callback.h"
31 #undef private
32 #undef protected
33
34 namespace OHOS {
35 namespace DistributedDeviceProfile {
36 using namespace testing::ext;
37 using namespace OHOS::NativeRdb;
38 using namespace std;
39 namespace {
40 const std::string TAG = "TrustProfileManagerTest";
41 }
42 class TrustProfileManagerTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48 int ResultSize(std::shared_ptr<ResultSet>& resultSet);
49 };
50
SetUpTestCase()51 void TrustProfileManagerTest::SetUpTestCase()
52 {
53 int32_t ret = OHOS::DistributedDeviceProfile::
54 TrustProfileManager::GetInstance().Init();
55 EXPECT_EQ(ret, DP_SUCCESS);
56 }
57
TearDownTestCase()58 void TrustProfileManagerTest::TearDownTestCase()
59 {
60 int32_t ret = OHOS::DistributedDeviceProfile::
61 TrustProfileManager::GetInstance().Init();
62 EXPECT_EQ(ret, DP_SUCCESS);
63
64 ret = OHOS::DistributedDeviceProfile::
65 TrustProfileManager::GetInstance().UnInit();
66 EXPECT_EQ(ret, DP_SUCCESS);
67 }
68
SetUp()69 void TrustProfileManagerTest::SetUp()
70 {
71 }
72
TearDown()73 void TrustProfileManagerTest::TearDown()
74 {
75 }
76
ResultSize(std::shared_ptr<ResultSet> & resultSet)77 int TrustProfileManagerTest::ResultSize(std::shared_ptr<ResultSet> &resultSet)
78 {
79 if (resultSet->GoToFirstRow() != E_OK) {
80 return 0;
81 }
82 int count;
83 resultSet->GetRowCount(count);
84 return count;
85 }
86
87 /*
88 * @tc.name: GetAllTrustDeviceProfile_002
89 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
90 * @tc.type: FUNC
91 */
92 HWTEST_F(TrustProfileManagerTest, GetAllTrustDeviceProfile_002, TestSize.Level1)
93 {
94 std::vector<TrustDeviceProfile> profile;
95 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
96 GetInstance().GetAllTrustDeviceProfile(profile);
97 EXPECT_NE(ret, DP_SUCCESS);
98 }
99
100 /*
101 * @tc.name: GetAllAccessControlProfile_002
102 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
103 * @tc.type: FUNC
104 */
105 HWTEST_F(TrustProfileManagerTest, GetAllAccessControlProfile_002, TestSize.Level1)
106 {
107 std::vector<AccessControlProfile> profile;
108 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
109 GetInstance().GetAllAccessControlProfile(profile);
110 for (size_t i = 0; i < profile.size(); i++) {
111 std::cout << profile[i].dump() <<std::endl;
112 std::cout << profile[i].GetAccesser().dump() <<std::endl;
113 std::cout << profile[i].GetAccessee().dump() <<std::endl;
114 }
115 EXPECT_NE(ret, DP_SUCCESS);
116 }
117
118 /*
119 * @tc.name: GetAccessControlProfile_013
120 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
121 * @tc.type: FUNC
122 */
123 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_013, TestSize.Level1)
124 {
125 std::vector<AccessControlProfile> profile;
126 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
127 GetInstance().GetAccessControlProfile(1, "111", profile);
128 EXPECT_NE(ret, DP_SUCCESS);
129
130 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
131 GetInstance().GetAccessControlProfile(1, profile);
132 EXPECT_NE(ret, DP_SUCCESS);
133
134 std::map<std::string, std::string> parms;
135 parms.insert({{"trustDeviceId", "9999"}, {"status", "1"}});
136 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
137 GetInstance().GetAccessControlProfile(parms, profile);
138 EXPECT_NE(ret, DP_SUCCESS);
139
140 parms.clear();
141 parms.insert({{"bundleName", "b1"}, {"bindtype", "9999"}, {"status", "1"}});
142 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
143 GetInstance().GetAccessControlProfile(parms, profile);
144 EXPECT_NE(ret, DP_SUCCESS);
145
146 parms.clear();
147 parms.insert({{"accountId", "b1"}});
148 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
149 GetInstance().GetAccessControlProfile(parms, profile);
150 EXPECT_NE(ret, DP_SUCCESS);
151
152 int32_t status;
153 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
154 GetInstance().GetResultStatus("1111", status);
155 EXPECT_NE(ret, DP_SUCCESS);
156
157 shared_ptr<ResultSet> resultRet = OHOS::DistributedDeviceProfile::TrustProfileManager::
158 GetInstance().GetResultSet("122", { ValueObject(1) });
159 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
160 GetInstance().GetAccessControlProfile(resultRet, 1, 1, profile);
161 EXPECT_NE(ret, DP_SUCCESS);
162
163 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
164 GetInstance().DeleteAccessControlProfileCheck(resultRet);
165 EXPECT_NE(ret, DP_SUCCESS);
166
167 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
168 GetInstance().GetAccessControlProfile(resultRet, 1, 1, profile);
169 EXPECT_NE(ret, DP_SUCCESS);
170 }
171
172 /*
173 * @tc.name: GetAccessControlProfile_013
174 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
175 * @tc.type: FUNC
176 */
177 HWTEST_F(TrustProfileManagerTest, Convert_001, TestSize.Level1)
178 {
179 shared_ptr<ResultSet> resultRet = OHOS::DistributedDeviceProfile::TrustProfileManager::
180 GetInstance().GetResultSet("122", { ValueObject(1) });
181 TrustDeviceProfile trustProfile;
182 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
183 GetInstance().ConvertToTrustDeviceProfile(resultRet, trustProfile);
184 EXPECT_NE(ret, DP_SUCCESS);
185
186 Accessee accessee;
187 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
188 GetInstance().ConvertToAccessee(resultRet, accessee);
189 EXPECT_NE(ret, DP_SUCCESS);
190
191 Accesser accesser;
192 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
193 GetInstance().ConvertToAccesser(resultRet, accesser);
194 EXPECT_NE(ret, DP_SUCCESS);
195
196 AccessControlProfile profile;
197 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
198 GetInstance().ConvertToAccessControlProfile(resultRet, profile);
199 EXPECT_NE(ret, DP_SUCCESS);
200
201 profile.SetAccessControlId(666);
202 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
203 GetInstance().UpdateAclCheck(profile);
204 EXPECT_NE(ret, DP_SUCCESS);
205
206 profile.SetTrustDeviceId("4546456");
207 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
208 GetInstance().UpdateAclCheck(profile);
209 EXPECT_NE(ret, DP_SUCCESS);
210 }
211
212 /*
213 * @tc.name: DeleteTrustDeviceProfile_001
214 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
215 * @tc.type: FUNC
216 */
217 HWTEST_F(TrustProfileManagerTest, DeleteTrustDeviceProfile_001, TestSize.Level1)
218 {
219 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
220 GetInstance().DeleteTrustDeviceProfile("12215656");
221 EXPECT_NE(ret, DP_SUCCESS);
222 }
223
224 /*
225 * @tc.name: PutAccessControlProfile_001
226 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
227 * @tc.type: FUNC
228 */
229 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_001, TestSize.Level1)
230 {
231 Accesser accesser;
232 accesser.SetAccesserDeviceId("acer1");
233 accesser.SetAccesserUserId(11);
234 accesser.SetAccesserAccountId("a1");
235 accesser.SetAccesserTokenId(111);
236 accesser.SetAccesserBundleName("b1");
237 accesser.SetAccesserHapSignature("h1");
238 accesser.SetAccesserBindLevel(1);
239
240 Accessee accessee;
241 accessee.SetAccesseeDeviceId("acee1");
242 accessee.SetAccesseeUserId(22);
243 accessee.SetAccesseeAccountId("a1");
244 accessee.SetAccesseeTokenId(222);
245 accessee.SetAccesseeBundleName("bb1");
246 accessee.SetAccesseeHapSignature("h1");
247 accessee.SetAccesseeBindLevel(1);
248
249 AccessControlProfile profile;
250 profile.SetTrustDeviceId("123456");
251 profile.SetSessionKey("key1");
252 profile.SetBindType(256);
253 profile.SetAuthenticationType(1);
254 profile.SetDeviceIdType(1);
255 profile.SetDeviceIdHash("abcd");
256 profile.SetStatus(0);
257 profile.SetValidPeriod(1);
258 profile.SetLastAuthTime(5);
259 profile.SetBindLevel(1);
260
261 profile.SetAccesser(accesser);
262 profile.SetAccessee(accessee);
263
264 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
265 GetInstance().PutAccessControlProfile(profile);
266 EXPECT_EQ(ret, DP_SUCCESS);
267
268 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
269 GetInstance().PutAccessControlProfile(profile);
270 EXPECT_EQ(ret, DP_SUCCESS);
271 }
272
273 /*
274 * @tc.name: PutTrustDeviceProfile_001
275 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
276 * @tc.type: FUNC
277 */
278 HWTEST_F(TrustProfileManagerTest, PutTrustDeviceProfile_001, TestSize.Level1)
279 {
280 AccessControlProfile profile;
281 profile.SetTrustDeviceId("123456");
282 profile.SetSessionKey("key1");
283 profile.SetBindType(256);
284 profile.SetAuthenticationType(1);
285 profile.SetDeviceIdType(1);
286 profile.SetDeviceIdHash("abcd");
287 profile.SetStatus(0);
288 profile.SetValidPeriod(1);
289 profile.SetLastAuthTime(5);
290 profile.SetBindLevel(1);
291
292 TrustDeviceProfile trustProfile;
293 OHOS::DistributedDeviceProfile::TrustProfileManager::
294 GetInstance().ConvertToTrustDeviceProfile(profile, trustProfile);
295 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
296 GetInstance().PutTrustDeviceProfile(trustProfile);
297 EXPECT_NE(ret, DP_SUCCESS);
298 }
299
300 /*
301 * @tc.name: PutAccessControlProfile_011
302 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
303 * @tc.type: FUNC
304 */
305 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_011, TestSize.Level1)
306 {
307 Accesser accesser;
308 accesser.SetAccesserDeviceId("acer11");
309 accesser.SetAccesserUserId(11);
310 accesser.SetAccesserAccountId("a11");
311 accesser.SetAccesserTokenId(111);
312 accesser.SetAccesserBundleName("b11");
313 accesser.SetAccesserHapSignature("h11");
314 accesser.SetAccesserBindLevel(1);
315
316 Accessee accessee;
317 accessee.SetAccesseeDeviceId("acee11");
318 accessee.SetAccesseeUserId(22);
319 accessee.SetAccesseeAccountId("a11");
320 accessee.SetAccesseeTokenId(222);
321 accessee.SetAccesseeBundleName("bb11");
322 accessee.SetAccesseeHapSignature("h11");
323 accessee.SetAccesseeBindLevel(1);
324
325 AccessControlProfile profile;
326 profile.SetTrustDeviceId("123456");
327 profile.SetSessionKey("key1");
328 profile.SetBindType(256);
329 profile.SetAuthenticationType(1);
330 profile.SetDeviceIdType(1);
331 profile.SetDeviceIdHash("abcd");
332 profile.SetStatus(0);
333 profile.SetValidPeriod(1);
334 profile.SetLastAuthTime(5);
335 profile.SetBindLevel(1);
336
337 profile.SetAccesser(accesser);
338 profile.SetAccessee(accessee);
339
340 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
341 GetInstance().PutAccessControlProfile(profile);
342 EXPECT_EQ(ret, DP_SUCCESS);
343 }
344
345 /*
346 * @tc.name: PutAccessControlProfile_002
347 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
348 * @tc.type: FUNC
349 */
350 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_002, TestSize.Level1)
351 {
352 Accesser accesser;
353 accesser.SetAccesserDeviceId("acer2");
354 accesser.SetAccesserUserId(33);
355 accesser.SetAccesserAccountId("a2");
356 accesser.SetAccesserTokenId(333);
357 accesser.SetAccesserBundleName("b2");
358 accesser.SetAccesserHapSignature("h2");
359 accesser.SetAccesserBindLevel(1);
360
361 Accessee accessee;
362 accessee.SetAccesseeDeviceId("acee2");
363 accessee.SetAccesseeUserId(44);
364 accessee.SetAccesseeAccountId("a2");
365 accessee.SetAccesseeTokenId(444);
366 accessee.SetAccesseeBundleName("bb2");
367 accessee.SetAccesseeHapSignature("h2");
368 accessee.SetAccesseeBindLevel(1);
369
370 AccessControlProfile profile;
371 profile.SetTrustDeviceId("123456");
372 profile.SetSessionKey("key1");
373 profile.SetBindType(256);
374 profile.SetAuthenticationType(1);
375 profile.SetDeviceIdType(1);
376 profile.SetDeviceIdHash("abcd");
377 profile.SetStatus(1);
378 profile.SetValidPeriod(99);
379 profile.SetLastAuthTime(66);
380 profile.SetBindLevel(1);
381
382 profile.SetAccesser(accesser);
383 profile.SetAccessee(accessee);
384
385 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
386 GetInstance().PutAccessControlProfile(profile);
387 EXPECT_EQ(ret, DP_SUCCESS);
388 }
389
390 /*
391 * @tc.name: PutAccessControlProfile_022
392 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
393 * @tc.type: FUNC
394 */
395 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_022, TestSize.Level1)
396 {
397 Accesser accesser;
398 accesser.SetAccesserDeviceId("acer22");
399 accesser.SetAccesserUserId(33);
400 accesser.SetAccesserAccountId("a22");
401 accesser.SetAccesserTokenId(333);
402 accesser.SetAccesserBundleName("b22");
403 accesser.SetAccesserHapSignature("h22");
404 accesser.SetAccesserBindLevel(1);
405
406 Accessee accessee;
407 accessee.SetAccesseeDeviceId("acee22");
408 accessee.SetAccesseeUserId(555);
409 accessee.SetAccesseeAccountId("a2");
410 accessee.SetAccesseeTokenId(444);
411 accessee.SetAccesseeBundleName("bb2");
412 accessee.SetAccesseeHapSignature("h2");
413 accessee.SetAccesseeBindLevel(1);
414
415 AccessControlProfile profile;
416 profile.SetTrustDeviceId("123456");
417 profile.SetSessionKey("key1");
418 profile.SetBindType(256);
419 profile.SetAuthenticationType(1);
420 profile.SetDeviceIdType(1);
421 profile.SetDeviceIdHash("abcd");
422 profile.SetStatus(0);
423 profile.SetValidPeriod(99);
424 profile.SetLastAuthTime(66);
425 profile.SetBindLevel(1);
426
427 profile.SetAccesser(accesser);
428 profile.SetAccessee(accessee);
429
430 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
431 GetInstance().PutAccessControlProfile(profile);
432 EXPECT_EQ(ret, DP_SUCCESS);
433 }
434
435 /*
436 * @tc.name: PutAccessControlProfile_003
437 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
438 * @tc.type: FUNC
439 */
440 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_003, TestSize.Level1)
441 {
442 Accesser accesser;
443 accesser.SetAccesserDeviceId("acer3");
444 accesser.SetAccesserUserId(55);
445 accesser.SetAccesserAccountId("a3");
446 accesser.SetAccesserTokenId(555);
447 accesser.SetAccesserBundleName("b3");
448 accesser.SetAccesserHapSignature("h3");
449 accesser.SetAccesserBindLevel(1);
450
451 Accessee accessee;
452 accessee.SetAccesseeDeviceId("acee3");
453 accessee.SetAccesseeUserId(66);
454 accessee.SetAccesseeAccountId("a3");
455 accessee.SetAccesseeTokenId(666);
456 accessee.SetAccesseeBundleName("bb3");
457 accessee.SetAccesseeHapSignature("h3");
458 accessee.SetAccesseeBindLevel(1);
459
460 AccessControlProfile profile;
461 profile.SetTrustDeviceId("6666");
462 profile.SetSessionKey("key1");
463 profile.SetBindType(3);
464 profile.SetAuthenticationType(1);
465 profile.SetDeviceIdType(1);
466 profile.SetDeviceIdHash("abcd");
467 profile.SetStatus(1);
468 profile.SetValidPeriod(1);
469 profile.SetLastAuthTime(5);
470 profile.SetBindLevel(1);
471
472 profile.SetAccesser(accesser);
473 profile.SetAccessee(accessee);
474
475 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
476 GetInstance().PutAccessControlProfile(profile);
477 EXPECT_EQ(ret, DP_SUCCESS);
478 }
479
480 /*
481 * @tc.name: PutAccessControlProfile_033
482 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
483 * @tc.type: FUNC
484 */
485 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_033, TestSize.Level1)
486 {
487 Accesser accesser;
488 accesser.SetAccesserDeviceId("acer33");
489 accesser.SetAccesserUserId(10086);
490 accesser.SetAccesserAccountId("a33");
491 accesser.SetAccesserTokenId(555);
492 accesser.SetAccesserBundleName("b3");
493 accesser.SetAccesserHapSignature("h33");
494 accesser.SetAccesserBindLevel(1);
495
496 Accessee accessee;
497 accessee.SetAccesseeDeviceId("acee33");
498 accessee.SetAccesseeUserId(10010);
499 accessee.SetAccesseeAccountId("a33");
500 accessee.SetAccesseeTokenId(666);
501 accessee.SetAccesseeBundleName("bb33");
502 accessee.SetAccesseeHapSignature("h33");
503 accessee.SetAccesseeBindLevel(1);
504
505 AccessControlProfile profile;
506 profile.SetTrustDeviceId("6666");
507 profile.SetSessionKey("key1");
508 profile.SetBindType(3);
509 profile.SetAuthenticationType(33);
510 profile.SetDeviceIdType(33);
511 profile.SetDeviceIdHash("abcd33");
512 profile.SetStatus(1);
513 profile.SetValidPeriod(1);
514 profile.SetLastAuthTime(5);
515 profile.SetBindLevel(1);
516
517 profile.SetAccesser(accesser);
518 profile.SetAccessee(accessee);
519
520 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
521 GetInstance().PutAccessControlProfile(profile);
522 EXPECT_EQ(ret, DP_SUCCESS);
523 }
524
525 /*
526 * @tc.name: PutAccessControlProfile_004
527 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
528 * @tc.type: FUNC
529 */
530 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_004, TestSize.Level1)
531 {
532 Accesser accesser;
533 accesser.SetAccesserDeviceId("acer4");
534 accesser.SetAccesserUserId(77);
535 accesser.SetAccesserAccountId("a4");
536 accesser.SetAccesserTokenId(777);
537 accesser.SetAccesserBundleName("b4");
538 accesser.SetAccesserHapSignature("h4");
539 accesser.SetAccesserBindLevel(1);
540
541 Accessee accessee;
542 accessee.SetAccesseeDeviceId("acee4");
543 accessee.SetAccesseeUserId(88);
544 accessee.SetAccesseeAccountId("a4");
545 accessee.SetAccesseeTokenId(888);
546 accessee.SetAccesseeBundleName("bb4");
547 accessee.SetAccesseeHapSignature("h4");
548 accessee.SetAccesseeBindLevel(1);
549
550 AccessControlProfile profile;
551 profile.SetTrustDeviceId("6666");
552 profile.SetSessionKey("key1");
553 profile.SetBindType(4);
554 profile.SetAuthenticationType(99);
555 profile.SetDeviceIdType(1);
556 profile.SetDeviceIdHash("abcd");
557 profile.SetStatus(0);
558 profile.SetValidPeriod(66);
559 profile.SetLastAuthTime(20);
560 profile.SetBindLevel(0);
561
562 profile.SetAccesser(accesser);
563 profile.SetAccessee(accessee);
564
565 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
566 GetInstance().PutAccessControlProfile(profile);
567 EXPECT_EQ(ret, DP_SUCCESS);
568 }
569
570 /*
571 * @tc.name: PutAccessControlProfile_044
572 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
573 * @tc.type: FUNC
574 */
575 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_044, TestSize.Level1)
576 {
577 Accesser accesser;
578 accesser.SetAccesserDeviceId("acer44");
579 accesser.SetAccesserUserId(77);
580 accesser.SetAccesserAccountId("a44");
581 accesser.SetAccesserTokenId(777);
582 accesser.SetAccesserBundleName("b4");
583 accesser.SetAccesserHapSignature("h44");
584 accesser.SetAccesserBindLevel(1);
585
586 Accessee accessee;
587 accessee.SetAccesseeDeviceId("acee44");
588 accessee.SetAccesseeUserId(88);
589 accessee.SetAccesseeAccountId("a44");
590 accessee.SetAccesseeTokenId(888);
591 accessee.SetAccesseeBundleName("bb4");
592 accessee.SetAccesseeHapSignature("h44");
593 accessee.SetAccesseeBindLevel(1);
594
595 AccessControlProfile profile;
596 profile.SetTrustDeviceId("9999");
597 profile.SetSessionKey("key1");
598 profile.SetBindType(4);
599 profile.SetAuthenticationType(100);
600 profile.SetDeviceIdType(1);
601 profile.SetDeviceIdHash("abcd");
602 profile.SetStatus(0);
603 profile.SetValidPeriod(66);
604 profile.SetLastAuthTime(20);
605 profile.SetBindLevel(0);
606
607 profile.SetAccesser(accesser);
608 profile.SetAccessee(accessee);
609
610 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
611 GetInstance().PutAccessControlProfile(profile);
612 EXPECT_EQ(ret, DP_SUCCESS);
613 }
614
615 /*
616 * @tc.name: PutAccessControlProfile_005
617 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
618 * @tc.type: FUNC
619 */
620 HWTEST_F(TrustProfileManagerTest, PutAccessControlProfile_005, TestSize.Level1)
621 {
622 Accesser accesser;
623 accesser.SetAccesserDeviceId("acer44");
624 accesser.SetAccesserUserId(77);
625 accesser.SetAccesserAccountId("a44");
626 accesser.SetAccesserTokenId(777);
627 accesser.SetAccesserBundleName("b4");
628 accesser.SetAccesserHapSignature("h44");
629 accesser.SetAccesserBindLevel(1);
630
631 Accessee accessee;
632 accessee.SetAccesseeDeviceId("acee4");
633 accessee.SetAccesseeUserId(88);
634 accessee.SetAccesseeAccountId("a4");
635 accessee.SetAccesseeTokenId(888);
636 accessee.SetAccesseeBundleName("bb4");
637 accessee.SetAccesseeHapSignature("h4");
638 accessee.SetAccesseeBindLevel(1);
639
640 AccessControlProfile profile;
641 profile.SetTrustDeviceId("9999");
642 profile.SetSessionKey("key1");
643 profile.SetBindType(4);
644 profile.SetAuthenticationType(100);
645 profile.SetDeviceIdType(1);
646 profile.SetDeviceIdHash("abcd");
647 profile.SetStatus(1);
648 profile.SetValidPeriod(66);
649 profile.SetLastAuthTime(20);
650 profile.SetBindLevel(0);
651
652 profile.SetAccesser(accesser);
653 profile.SetAccessee(accessee);
654
655 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
656 GetInstance().PutAccessControlProfile(profile);
657 EXPECT_EQ(ret, DP_SUCCESS);
658 }
659
660 /*
661 * @tc.name: GetAccessControlProfile_001
662 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
663 * @tc.type: FUNC
664 */
665 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_001, TestSize.Level1)
666 {
667 std::vector<AccessControlProfile> profile;
668 std::map<std::string, std::string> parms;
669 parms.insert({{"userId", "22"}, {"bundleName", "bb1"}, {"bindType", "256"}, {"status", "0"}});
670 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
671 GetInstance().GetAccessControlProfile(parms, profile);
672 for (size_t i = 0; i < profile.size(); i++) {
673 std::cout << profile[i].dump() <<std::endl;
674 ValuesBucket value;
675 ProfileUtils::AccessControlProfileToEntries(profile[i], value);
676 AccessControlProfile aclProfile;
677 ProfileUtils::EntriesToAccessControlProfile(value, aclProfile);
678 value.Clear();
679 std::cout << profile[i].GetAccesser().dump() <<std::endl;
680 ProfileUtils::AccesserToEntries(profile[i], value);
681 Accesser accesser;
682 ProfileUtils::EntriesToAccesser(value, accesser);
683 value.Clear();
684 std::cout << profile[i].GetAccessee().dump() <<std::endl;
685 ProfileUtils::AccesseeToEntries(profile[i], value);
686 Accessee accessee;
687 ProfileUtils::EntriesToAccessee(value, accessee);
688 value.Clear();
689 }
690 EXPECT_EQ(ret, DP_SUCCESS);
691
692 parms.clear();
693 profile.clear();
694 parms.insert({{"userId", "11"}, {"bundleName", "b1"}, {"bindType", "256"}, {"status", "0"}});
695 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
696 GetInstance().GetAccessControlProfile(parms, profile);
697 for (size_t i = 0; i < profile.size(); i++) {
698 std::cout << profile[i].dump() <<std::endl;
699 std::cout << profile[i].GetAccesser().dump() <<std::endl;
700 std::cout << profile[i].GetAccessee().dump() <<std::endl;
701 }
702 EXPECT_EQ(ret, DP_SUCCESS);
703 }
704
705 /*
706 * @tc.name: GetAccessControlProfile_002
707 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
708 * @tc.type: FUNC
709 */
710 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_002, TestSize.Level1)
711 {
712 std::vector<AccessControlProfile> profile;
713 std::map<std::string, std::string> parms;
714 parms.insert({{"userId", "555"}, {"bundleName", "b1"}, {"trustDeviceId", "123456"}, {"status", "0"}});
715 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
716 GetInstance().GetAccessControlProfile(parms, profile);
717 for (size_t i = 0; i < profile.size(); i++) {
718 std::cout << profile[i].dump() <<std::endl;
719 std::cout << profile[i].GetAccesser().dump() <<std::endl;
720 std::cout << profile[i].GetAccessee().dump() <<std::endl;
721 }
722 EXPECT_EQ(ret, DP_SUCCESS);
723
724 parms.clear();
725 profile.clear();
726 parms.insert({{"userId", "33"}, {"bundleName", "b1"}, {"trustDeviceId", "123456"}, {"status", "0"}});
727 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
728 GetInstance().GetAccessControlProfile(parms, profile);
729 for (size_t i = 0; i < profile.size(); i++) {
730 std::cout << profile[i].dump() <<std::endl;
731 std::cout << profile[i].GetAccesser().dump() <<std::endl;
732 std::cout << profile[i].GetAccessee().dump() <<std::endl;
733 }
734 EXPECT_EQ(ret, DP_SUCCESS);
735 }
736
737 /*
738 * @tc.name: GetAccessControlProfile_003
739 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
740 * @tc.type: FUNC
741 */
742 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_003, TestSize.Level1)
743 {
744 std::vector<AccessControlProfile> profile;
745 std::map<std::string, std::string> parms;
746 parms.insert({{"bundleName", "bb3"}, {"trustDeviceId", "6666"}, {"status", "1"}});
747 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
748 GetInstance().GetAccessControlProfile(parms, profile);
749 for (size_t i = 0; i < profile.size(); i++) {
750 std::cout << profile[i].dump() <<std::endl;
751 std::cout << profile[i].GetAccesser().dump() <<std::endl;
752 std::cout << profile[i].GetAccessee().dump() <<std::endl;
753 }
754 EXPECT_EQ(ret, DP_SUCCESS);
755
756 parms.clear();
757 profile.clear();
758 parms.insert({{"bundleName", "b3"}, {"trustDeviceId", "6666"}, {"status", "1"}});
759 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
760 GetInstance().GetAccessControlProfile(parms, profile);
761 for (size_t i = 0; i < profile.size(); i++) {
762 std::cout << profile[i].dump() <<std::endl;
763 std::cout << profile[i].GetAccesser().dump() <<std::endl;
764 std::cout << profile[i].GetAccessee().dump() <<std::endl;
765 }
766 EXPECT_EQ(ret, DP_SUCCESS);
767 }
768
769 /*
770 * @tc.name: GetAccessControlProfile_004
771 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
772 * @tc.type: FUNC
773 */
774 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_004, TestSize.Level1)
775 {
776 std::vector<AccessControlProfile> profile;
777 std::map<std::string, std::string> parms;
778 parms.insert({{"bundleName", "bb4"}, {"bindType", "4"}, {"status", "0"}});
779 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
780 GetInstance().GetAccessControlProfile(parms, profile);
781 for (size_t i = 0; i < profile.size(); i++) {
782 std::cout << profile[i].dump() <<std::endl;
783 std::cout << profile[i].GetAccesser().dump() <<std::endl;
784 std::cout << profile[i].GetAccessee().dump() <<std::endl;
785 }
786 EXPECT_EQ(ret, DP_SUCCESS);
787 }
788
789 /*
790 * @tc.name: GetAccessControlProfile_005
791 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
792 * @tc.type: FUNC
793 */
794 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_005, TestSize.Level1)
795 {
796 std::vector<AccessControlProfile> profile;
797 std::map<std::string, std::string> parms;
798 parms.insert({{"userId", "77"}, {"accountId", "a44"}});
799 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
800 GetInstance().GetAccessControlProfile(parms, profile);
801 for (size_t i = 0; i < profile.size(); i++) {
802 std::cout << profile[i].dump() <<std::endl;
803 std::cout << profile[i].GetAccesser().dump() <<std::endl;
804 std::cout << profile[i].GetAccessee().dump() <<std::endl;
805 }
806 EXPECT_EQ(ret, DP_SUCCESS);
807
808 parms.clear();
809 profile.clear();
810 parms.insert({{"userId", "88"}, {"accountId", "a44"}});
811 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
812 GetInstance().GetAccessControlProfile(parms, profile);
813 EXPECT_EQ(ret, DP_SUCCESS);
814
815 parms.clear();
816 profile.clear();
817 parms.insert({{"userId", "88"}});
818 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
819 GetInstance().GetAccessControlProfile(parms, profile);
820 EXPECT_EQ(ret, DP_SUCCESS);
821
822 parms.clear();
823 profile.clear();
824 parms.insert({{"userId", "77"}});
825 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
826 GetInstance().GetAccessControlProfile(parms, profile);
827 for (size_t i = 0; i < profile.size(); i++) {
828 std::cout << profile[i].dump() <<std::endl;
829 std::cout << profile[i].GetAccesser().dump() <<std::endl;
830 std::cout << profile[i].GetAccessee().dump() <<std::endl;
831 }
832 EXPECT_EQ(ret, DP_SUCCESS);
833 }
834
835 /*
836 * @tc.name: GetAccessControlProfile_006
837 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
838 * @tc.type: FUNC
839 */
840 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_006, TestSize.Level1)
841 {
842 std::vector<AccessControlProfile> profile;
843 std::map<std::string, std::string> parms;
844 parms.insert({{"tokenId", "777"}, {"trustDeviceId", "acer44"}, {"status", "1"}});
845 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
846 GetInstance().GetAccessControlProfile(parms, profile);
847 for (size_t i = 0; i < profile.size(); i++) {
848 std::cout << profile[i].dump() <<std::endl;
849 std::cout << profile[i].GetAccesser().dump() <<std::endl;
850 std::cout << profile[i].GetAccessee().dump() <<std::endl;
851 }
852 EXPECT_EQ(ret, DP_SUCCESS);
853
854 parms.clear();
855 profile.clear();
856 parms.insert({{"tokenId", "888"}, {"trustDeviceId", "acee4"}, {"status", "1"}});
857 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
858 GetInstance().GetAccessControlProfile(parms, profile);
859 for (size_t i = 0; i < profile.size(); i++) {
860 std::cout << profile[i].dump() <<std::endl;
861 std::cout << profile[i].GetAccesser().dump() <<std::endl;
862 std::cout << profile[i].GetAccessee().dump() <<std::endl;
863 }
864 EXPECT_EQ(ret, DP_SUCCESS);
865 }
866
867 /*
868 * @tc.name: GetAccessControlProfile_007
869 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
870 * @tc.type: FUNC
871 */
872 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_007, TestSize.Level1)
873 {
874 std::vector<AccessControlProfile> profile;
875 std::map<std::string, std::string> parms;
876 parms.insert({{"userId", "33"}, {"bundleName", "b22"}, {"trustDeviceId", "123456"}, {"status", "0"}});
877 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
878 GetInstance().GetAccessControlProfile(parms, profile);
879 for (size_t i = 0; i < profile.size(); i++) {
880 std::cout << profile[i].dump() <<std::endl;
881 std::cout << profile[i].GetAccesser().dump() <<std::endl;
882 std::cout << profile[i].GetAccessee().dump() <<std::endl;
883 }
884 EXPECT_EQ(ret, DP_SUCCESS);
885 }
886
887 /*
888 * @tc.name: GetAccessControlProfile_008
889 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
890 * @tc.type: FUNC
891 */
892 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_008, TestSize.Level1)
893 {
894 std::vector<AccessControlProfile> profile;
895 std::map<std::string, std::string> parms;
896 parms.insert({{"userId", "77"}, {"bundleName", "b4"}, {"trustDeviceId", "9999"}, {"status", "1"}});
897 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
898 GetInstance().GetAccessControlProfile(parms, profile);
899 for (size_t i = 0; i < profile.size(); i++) {
900 std::cout << profile[i].dump() <<std::endl;
901 std::cout << profile[i].GetAccesser().dump() <<std::endl;
902 std::cout << profile[i].GetAccessee().dump() <<std::endl;
903 }
904 EXPECT_EQ(ret, DP_SUCCESS);
905
906 parms.clear();
907 profile.clear();
908 parms.insert({{"userId", "44"}, {"bundleName", "b4"}, {"trustDeviceId", "123456"}, {"status", "1"}});
909 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
910 GetInstance().GetAccessControlProfile(parms, profile);
911 for (size_t i = 0; i < profile.size(); i++) {
912 std::cout << profile[i].dump() <<std::endl;
913 std::cout << profile[i].GetAccesser().dump() <<std::endl;
914 std::cout << profile[i].GetAccessee().dump() <<std::endl;
915 }
916 EXPECT_EQ(ret, DP_SUCCESS);
917 }
918
919 /*
920 * @tc.name: GetAccessControlProfile_009
921 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
922 * @tc.type: FUNC
923 */
924 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_009, TestSize.Level1)
925 {
926 std::vector<AccessControlProfile> profile;
927 std::map<std::string, std::string> parms;
928 parms.insert({{"bundleName", "b4"}, {"bindType", "4"}, {"status", "0"}});
929 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
930 GetInstance().GetAccessControlProfile(parms, profile);
931 for (size_t i = 0; i < profile.size(); i++) {
932 std::cout << profile[i].dump() <<std::endl;
933 std::cout << profile[i].GetAccesser().dump() <<std::endl;
934 std::cout << profile[i].GetAccessee().dump() <<std::endl;
935 }
936 EXPECT_EQ(ret, DP_SUCCESS);
937 }
938
939 /*
940 * @tc.name: GetAccessControlProfile_010
941 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
942 * @tc.type: FUNC
943 */
944 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_010, TestSize.Level1)
945 {
946 std::vector<AccessControlProfile> profile;
947 std::map<std::string, std::string> parms;
948 parms.insert({{"bundleName", "888"}, {"bindType", "4"}, {"status", "1"}});
949 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
950 GetInstance().GetAccessControlProfile(parms, profile);
951 EXPECT_NE(ret, DP_SUCCESS);
952
953 parms.clear();
954 parms.insert({{"bundleName", "b4"}, {"bindType", "88"}, {"status", "8"}});
955 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
956 GetInstance().GetAccessControlProfile(parms, profile);
957 EXPECT_NE(ret, DP_SUCCESS);
958
959 parms.clear();
960 parms.insert({{"bundleName", "888"}, {"trustDeviceId", "9999"}, {"status", "1"}});
961 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
962 GetInstance().GetAccessControlProfile(parms, profile);
963 EXPECT_NE(ret, DP_SUCCESS);
964
965 parms.clear();
966 parms.insert({{"bundleName", "b4"}, {"trustDeviceId", "88888"}, {"status", "0"}});
967 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
968 GetInstance().GetAccessControlProfile(parms, profile);
969 EXPECT_NE(ret, DP_SUCCESS);
970
971 parms.clear();
972 parms.insert({{"userId", "88888"}, {"accountId", "a44"}});
973 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
974 GetInstance().GetAccessControlProfile(parms, profile);
975 EXPECT_NE(ret, DP_SUCCESS);
976
977 parms.clear();
978 parms.insert({{"userId", "88888"}});
979 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
980 GetInstance().GetAccessControlProfile(parms, profile);
981 EXPECT_NE(ret, DP_SUCCESS);
982 }
983
984 /*
985 * @tc.name: GetAccessControlProfile_011
986 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
987 * @tc.type: FUNC
988 */
989 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_011, TestSize.Level1)
990 {
991 std::vector<AccessControlProfile> profile;
992 std::map<std::string, std::string> parms;
993 parms.insert({{"tokenId", "55555"}, {"trustDeviceId", "11111"}, {"status", "1"}});
994 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
995 GetInstance().GetAccessControlProfile(parms, profile);
996 EXPECT_NE(ret, DP_SUCCESS);
997
998 parms.clear();
999 parms.insert({{"tokenId", "55555"}, {"trustDeviceId", "9999"}, {"status", "1"}});
1000 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1001 GetInstance().GetAccessControlProfile(parms, profile);
1002 EXPECT_NE(ret, DP_SUCCESS);
1003
1004 parms.clear();
1005 parms.insert({{"userId", "001"}, {"bundleName", "b1"}, {"trustDeviceId", "9999"}, {"status", "1"}});
1006 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1007 GetInstance().GetAccessControlProfile(parms, profile);
1008 EXPECT_NE(ret, DP_SUCCESS);
1009
1010 parms.clear();
1011 parms.insert({{"userId", "001"}, {"bundleName", "b1"}, {"trustDeviceId", "99999"}, {"status", "1"}});
1012 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1013 GetInstance().GetAccessControlProfile(parms, profile);
1014 EXPECT_NE(ret, DP_SUCCESS);
1015
1016 parms.clear();
1017 parms.insert({{"userId", "001"}, {"bundleName", "b1"}, {"bindType", "99999"}, {"status", "1"}});
1018 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1019 GetInstance().GetAccessControlProfile(parms, profile);
1020 EXPECT_NE(ret, DP_SUCCESS);
1021
1022 parms.clear();
1023 parms.insert({{"userId", "001"}, {"bundleName", "b1"}, {"bindType", "4"}, {"status", "1"}});
1024 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1025 GetInstance().GetAccessControlProfile(parms, profile);
1026 EXPECT_NE(ret, DP_SUCCESS);
1027 }
1028
1029 /*
1030 * @tc.name: GetAccessControlProfile_012
1031 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1032 * @tc.type: FUNC
1033 */
1034 HWTEST_F(TrustProfileManagerTest, GetAccessControlProfile_012, TestSize.Level1)
1035 {
1036 string invalid;
1037 std::vector<ValueObject> val;
1038 for (int i = 0; i < 4100; ++i) {
1039 val.push_back(ValueObject(1));
1040 invalid += "1";
1041 }
1042 std::vector<AccessControlProfile> profile;
1043 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1044 GetInstance().GetAccessControlProfile(invalid, "99999", 1, profile);
1045 EXPECT_NE(ret, DP_SUCCESS);
1046
1047 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1048 GetInstance().GetAccessControlProfile("b1", invalid, 1, profile);
1049 EXPECT_NE(ret, DP_SUCCESS);
1050
1051 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1052 GetInstance().GetAccessControlProfile(invalid, 4, 1, profile);
1053 EXPECT_NE(ret, DP_SUCCESS);
1054
1055 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1056 GetInstance().GetAccessControlProfile(1, invalid, 4, 1, profile);
1057 EXPECT_NE(ret, DP_SUCCESS);
1058
1059 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1060 GetInstance().GetAccessControlProfile(1, invalid, "99999", 1, profile);
1061 EXPECT_NE(ret, DP_SUCCESS);
1062
1063 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1064 GetInstance().GetAccessControlProfile(1, "b1", invalid, 1, profile);
1065 EXPECT_NE(ret, DP_SUCCESS);
1066
1067 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1068 GetInstance().GetAccessControlProfileByTokenId(1, invalid, 1, profile);
1069 EXPECT_NE(ret, DP_SUCCESS);
1070
1071 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1072 GetInstance().GetAccessControlProfile(1, invalid, profile);
1073 EXPECT_NE(ret, DP_SUCCESS);
1074
1075 OHOS::DistributedDeviceProfile::TrustProfileManager::GetInstance().
1076 GetResultSet(invalid, std::vector<ValueObject> {});
1077
1078 OHOS::DistributedDeviceProfile::TrustProfileManager::
1079 GetInstance().GetResultSet("111", val);
1080 }
1081
1082 /*
1083 * @tc.name: UpdateAccessControlProfile_001
1084 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1085 * @tc.type: FUNC
1086 */
1087 HWTEST_F(TrustProfileManagerTest, UpdateAccessControlProfile_001, TestSize.Level1)
1088 {
1089 Accesser accesser;
1090 accesser.SetAccesserId(1);
1091 accesser.SetAccesserDeviceId("upacer1");
1092 accesser.SetAccesserUserId(101);
1093 accesser.SetAccesserAccountId("upa1");
1094 accesser.SetAccesserTokenId(1001);
1095 accesser.SetAccesserBundleName("b1");
1096 accesser.SetAccesserHapSignature("uph1");
1097 accesser.SetAccesserBindLevel(1);
1098
1099 Accessee accessee;
1100 accessee.SetAccesseeId(1);
1101 accessee.SetAccesseeDeviceId("upacee1");
1102 accessee.SetAccesseeUserId(22);
1103 accessee.SetAccesseeAccountId("upa1");
1104 accessee.SetAccesseeTokenId(2002);
1105 accessee.SetAccesseeBundleName("yyy");
1106 accessee.SetAccesseeHapSignature("uph1");
1107 accessee.SetAccesseeBindLevel(1);
1108
1109 AccessControlProfile profile;
1110 profile.SetAccessControlId(1);
1111 profile.SetAccesserId(1);
1112 profile.SetAccesseeId(1);
1113 profile.SetTrustDeviceId("123456");
1114 profile.SetSessionKey("key1");
1115 profile.SetBindType(1);
1116 profile.SetAuthenticationType(1);
1117 profile.SetDeviceIdType(1);
1118 profile.SetDeviceIdHash("abcd");
1119 profile.SetStatus(0);
1120 profile.SetValidPeriod(1);
1121 profile.SetLastAuthTime(5);
1122 profile.SetBindLevel(0);
1123
1124 profile.SetAccesser(accesser);
1125 profile.SetAccessee(accessee);
1126
1127 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1128 GetInstance().UpdateAccessControlProfile(profile);
1129 EXPECT_EQ(ret, DP_SUCCESS);
1130 }
1131
1132 /*
1133 * @tc.name: UpdateTrustDeviceProfile_001
1134 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1135 * @tc.type: FUNC
1136 */
1137 HWTEST_F(TrustProfileManagerTest, UpdateTrustDeviceProfile_001, TestSize.Level1)
1138 {
1139 TrustDeviceProfile profile;
1140 profile.SetDeviceId("56465456465");
1141
1142 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1143 GetInstance().UpdateTrustDeviceProfile(profile);
1144 EXPECT_NE(ret, DP_SUCCESS);
1145 }
1146
1147 /*
1148 * @tc.name: UpdateAccessControlProfile_002
1149 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1150 * @tc.type: FUNC
1151 */
1152 HWTEST_F(TrustProfileManagerTest, UpdateAccessControlProfile_002, TestSize.Level1)
1153 {
1154 Accesser accesser;
1155 accesser.SetAccesserId(3);
1156 accesser.SetAccesserDeviceId("upacer2");
1157 accesser.SetAccesserUserId(555);
1158 accesser.SetAccesserAccountId("upa1");
1159 accesser.SetAccesserTokenId(4444);
1160 accesser.SetAccesserBundleName("b1");
1161 accesser.SetAccesserHapSignature("uph1");
1162 accesser.SetAccesserBindLevel(1);
1163
1164 Accessee accessee;
1165 accessee.SetAccesseeId(3);
1166 accessee.SetAccesseeDeviceId("upacee2");
1167 accessee.SetAccesseeUserId(456);
1168 accessee.SetAccesseeAccountId("upa2");
1169 accessee.SetAccesseeTokenId(5555);
1170 accessee.SetAccesseeBundleName("b1");
1171 accessee.SetAccesseeHapSignature("uph2");
1172 accessee.SetAccesseeBindLevel(1);
1173
1174 AccessControlProfile profile;
1175 profile.SetAccessControlId(3);
1176 profile.SetAccesserId(3);
1177 profile.SetAccesseeId(3);
1178 profile.SetTrustDeviceId("123456");
1179 profile.SetSessionKey("key2");
1180 profile.SetBindType(2);
1181 profile.SetAuthenticationType(1);
1182 profile.SetDeviceIdType(1);
1183 profile.SetDeviceIdHash("abcd");
1184 profile.SetStatus(0);
1185 profile.SetValidPeriod(999);
1186 profile.SetLastAuthTime(666);
1187 profile.SetBindLevel(0);
1188
1189 profile.SetAccesser(accesser);
1190 profile.SetAccessee(accessee);
1191
1192 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1193 GetInstance().UpdateAccessControlProfile(profile);
1194 EXPECT_EQ(ret, DP_SUCCESS);
1195 }
1196
1197 /*
1198 * @tc.name: UpdateAccessControlProfile_003
1199 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1200 * @tc.type: FUNC
1201 */
1202 HWTEST_F(TrustProfileManagerTest, UpdateAccessControlProfile_003, TestSize.Level1)
1203 {
1204 Accesser accesser;
1205 accesser.SetAccesserId(5);
1206 accesser.SetAccesserDeviceId("upacer3");
1207 accesser.SetAccesserUserId(55);
1208 accesser.SetAccesserAccountId("upa3");
1209 accesser.SetAccesserTokenId(555);
1210 accesser.SetAccesserBundleName("b3");
1211 accesser.SetAccesserHapSignature("uph3");
1212 accesser.SetAccesserBindLevel(1);
1213
1214 Accessee accessee;
1215 accessee.SetAccesseeId(5);
1216 accessee.SetAccesseeDeviceId("upacee3");
1217 accessee.SetAccesseeUserId(66);
1218 accessee.SetAccesseeAccountId("upa3");
1219 accessee.SetAccesseeTokenId(6666);
1220 accessee.SetAccesseeBundleName("bb3");
1221 accessee.SetAccesseeHapSignature("uph3");
1222 accessee.SetAccesseeBindLevel(1);
1223
1224 AccessControlProfile profile;
1225 profile.SetAccessControlId(5);
1226 profile.SetAccesserId(5);
1227 profile.SetAccesseeId(5);
1228 profile.SetTrustDeviceId("6666");
1229 profile.SetSessionKey("key1");
1230 profile.SetBindType(3);
1231 profile.SetAuthenticationType(1);
1232 profile.SetDeviceIdType(1);
1233 profile.SetDeviceIdHash("aaaa");
1234 profile.SetStatus(1);
1235 profile.SetValidPeriod(1);
1236 profile.SetLastAuthTime(5);
1237 profile.SetBindLevel(1);
1238
1239 profile.SetAccesser(accesser);
1240 profile.SetAccessee(accessee);
1241
1242 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1243 GetInstance().UpdateAccessControlProfile(profile);
1244 EXPECT_EQ(ret, DP_SUCCESS);
1245 }
1246
1247 /*
1248 * @tc.name: DeleteAccessControlProfile_001
1249 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1250 * @tc.type: FUNC
1251 */
1252 HWTEST_F(TrustProfileManagerTest, DeleteAccessControlProfile_001, TestSize.Level1)
1253 {
1254 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1255 GetInstance().DeleteAccessControlProfile(9);
1256 EXPECT_EQ(ret, DP_SUCCESS);
1257 }
1258
1259 /*
1260 * @tc.name: DeleteAccessControlProfile_002
1261 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1262 * @tc.type: FUNC
1263 */
1264 HWTEST_F(TrustProfileManagerTest, DeleteAccessControlProfile_002, TestSize.Level1)
1265 {
1266 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1267 GetInstance().DeleteAccessControlProfile(8);
1268 EXPECT_EQ(ret, DP_SUCCESS);
1269 }
1270
1271 /*
1272 * @tc.name: DeleteAccessControlProfile_003
1273 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1274 * @tc.type: FUNC
1275 */
1276 HWTEST_F(TrustProfileManagerTest, DeleteAccessControlProfile_003, TestSize.Level1)
1277 {
1278 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1279 GetInstance().DeleteAccessControlProfile(5);
1280 EXPECT_EQ(ret, DP_SUCCESS);
1281 }
1282
1283 /*
1284 * @tc.name: DeleteAccessControlProfile_004
1285 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1286 * @tc.type: FUNC
1287 */
1288 HWTEST_F(TrustProfileManagerTest, DeleteAccessControlProfile_004, TestSize.Level1)
1289 {
1290 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1291 GetInstance().DeleteAccessControlProfile(6);
1292 EXPECT_EQ(ret, DP_SUCCESS);
1293 }
1294
1295 /*
1296 * @tc.name: DeleteAccessControlProfile_005
1297 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1298 * @tc.type: FUNC
1299 */
1300 HWTEST_F(TrustProfileManagerTest, DeleteAccessControlProfile_005, TestSize.Level1)
1301 {
1302 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1303 GetInstance().DeleteAccessControlProfile(7);
1304 EXPECT_EQ(ret, DP_SUCCESS);
1305 }
1306
1307 /*
1308 * @tc.name: GetAllAccessControlProfile_001
1309 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1310 * @tc.type: FUNC
1311 */
1312 HWTEST_F(TrustProfileManagerTest, GetAllAccessControlProfile_001, TestSize.Level1)
1313 {
1314 std::vector<AccessControlProfile> profile;
1315 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1316 GetInstance().GetAllAccessControlProfile(profile);
1317 for (size_t i = 0; i < profile.size(); i++) {
1318 std::cout << profile[i].dump() <<std::endl;
1319 std::cout << profile[i].GetAccesser().dump() <<std::endl;
1320 std::cout << profile[i].GetAccessee().dump() <<std::endl;
1321 }
1322 EXPECT_EQ(ret, DP_SUCCESS);
1323 }
1324
1325 /*
1326 * @tc.name: GetAllTrustDeviceProfile_001
1327 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1328 * @tc.type: FUNC
1329 */
1330 HWTEST_F(TrustProfileManagerTest, GetAllTrustDeviceProfile_001, TestSize.Level1)
1331 {
1332 std::vector<TrustDeviceProfile> profile;
1333 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1334 GetInstance().GetAllTrustDeviceProfile(profile);
1335 for (size_t i = 0; i < profile.size(); i++) {
1336 std::cout << profile[i].dump() <<std::endl;
1337 }
1338 EXPECT_EQ(ret, DP_SUCCESS);
1339 }
1340
1341 /*
1342 * @tc.name: GetTrustDeviceProfile_001
1343 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1344 * @tc.type: FUNC
1345 */
1346 HWTEST_F(TrustProfileManagerTest, GetTrustDeviceProfile_001, TestSize.Level1)
1347 {
1348 TrustDeviceProfile profile;
1349 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1350 GetInstance().GetTrustDeviceProfile("123456", profile);
1351 ValuesBucket value;
1352 ProfileUtils::TrustDeviceProfileToEntries(profile, value);
1353 std::cout << profile.dump() <<std::endl;
1354 ProfileUtils::EntriesToTrustDeviceProfile(value, profile);
1355 EXPECT_EQ(ret, DP_SUCCESS);
1356 }
1357
1358 /*
1359 * @tc.name: GetTrustDeviceProfile_002
1360 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1361 * @tc.type: FUNC
1362 */
1363 HWTEST_F(TrustProfileManagerTest, GetTrustDeviceProfile_002, TestSize.Level1)
1364 {
1365 TrustDeviceProfile profile;
1366 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1367 GetInstance().GetTrustDeviceProfile("8888", profile);
1368 EXPECT_NE(ret, DP_SUCCESS);
1369 }
1370
1371 /*
1372 * @tc.name: DeleteAccessControlProfile_006
1373 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1374 * @tc.type: FUNC
1375 */
1376 HWTEST_F(TrustProfileManagerTest, DeleteAccessControlProfile_006, TestSize.Level1)
1377 {
1378 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1379 GetInstance().DeleteAccessControlProfile(10);
1380 EXPECT_NE(ret, DP_SUCCESS);
1381
1382 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1383 GetInstance().DeleteAccessControlProfile(4);
1384 EXPECT_EQ(ret, DP_SUCCESS);
1385
1386 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1387 GetInstance().DeleteAccessControlProfile(3);
1388 EXPECT_EQ(ret, DP_SUCCESS);
1389
1390 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1391 GetInstance().DeleteAccessControlProfile(2);
1392 EXPECT_EQ(ret, DP_SUCCESS);
1393
1394 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1395 GetInstance().DeleteAccessControlProfile(1);
1396 EXPECT_EQ(ret, DP_SUCCESS);
1397 }
1398
1399 /*
1400 * @tc.name: RdbStoreIsNullptr_001
1401 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1402 * @tc.type: FUNC
1403 */
1404 HWTEST_F(TrustProfileManagerTest, RdbStoreIsNullptr_001, TestSize.Level1)
1405 {
1406 OHOS::DistributedDeviceProfile::TrustProfileManager::
1407 GetInstance().rdbStore_ = nullptr;
1408
1409 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1410 GetInstance().UnInit();
1411 EXPECT_NE(ret, DP_SUCCESS);
1412
1413 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1414 GetInstance().CreateTable();
1415 EXPECT_NE(ret, DP_SUCCESS);
1416
1417 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1418 GetInstance().CreateUniqueIndex();
1419 EXPECT_NE(ret, DP_SUCCESS);
1420
1421 TrustDeviceProfile profile;
1422 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1423 GetInstance().GetTrustDeviceProfile("8888", profile);
1424 EXPECT_NE(ret, DP_SUCCESS);
1425
1426 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1427 GetInstance().PutTrustDeviceProfile(profile);
1428 EXPECT_NE(ret, DP_SUCCESS);
1429
1430 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1431 GetInstance().UpdateTrustDeviceProfile(profile);
1432 EXPECT_NE(ret, DP_SUCCESS);
1433
1434 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1435 GetInstance().DeleteTrustDeviceProfile("123");
1436 EXPECT_NE(ret, DP_SUCCESS);
1437
1438 std::vector<TrustDeviceProfile> profiles;
1439 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1440 GetInstance().GetAllTrustDeviceProfile(profiles);
1441 EXPECT_NE(ret, DP_SUCCESS);
1442 }
1443
1444 /*
1445 * @tc.name: RdbStoreIsNullptr_002
1446 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1447 * @tc.type: FUNC
1448 */
1449 HWTEST_F(TrustProfileManagerTest, RdbStoreIsNullptr_002, TestSize.Level1)
1450 {
1451 OHOS::DistributedDeviceProfile::TrustProfileManager::
1452 GetInstance().rdbStore_ = nullptr;
1453
1454 AccessControlProfile profile;
1455 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1456 GetInstance().PutAccessControlProfile(profile);
1457 EXPECT_NE(ret, DP_SUCCESS);
1458
1459 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1460 GetInstance().UpdateAccessControlProfile(profile);
1461 EXPECT_NE(ret, DP_SUCCESS);
1462
1463 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1464 GetInstance().DeleteAccessControlProfile(1);
1465 EXPECT_NE(ret, DP_SUCCESS);
1466
1467 std::vector<AccessControlProfile> profiles;
1468 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1469 GetInstance().GetAllAccessControlProfile(profiles);
1470 EXPECT_NE(ret, DP_SUCCESS);
1471
1472 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1473 GetInstance().PutAccesserProfile(profile);
1474 EXPECT_NE(ret, DP_SUCCESS);
1475
1476 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1477 GetInstance().PutAccesseeProfile(profile);
1478 EXPECT_NE(ret, DP_SUCCESS);
1479
1480 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1481 GetInstance().SetAccessControlId(profile);
1482 EXPECT_NE(ret, DP_SUCCESS);
1483
1484 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1485 GetInstance().SetAccesserId(profile);
1486 EXPECT_NE(ret, DP_SUCCESS);
1487
1488 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1489 GetInstance().SetAccesseeId(profile);
1490 EXPECT_NE(ret, DP_SUCCESS);
1491
1492 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1493 GetInstance().UpdateAccesserProfile(1, profile);
1494 EXPECT_NE(ret, DP_SUCCESS);
1495
1496 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1497 GetInstance().UpdateAccesseeProfile(1, profile);
1498 EXPECT_NE(ret, DP_SUCCESS);
1499 }
1500
1501 /*
1502 * @tc.name: RdbStoreIsNullptr_003
1503 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1504 * @tc.type: FUNC
1505 */
1506 HWTEST_F(TrustProfileManagerTest, RdbStoreIsNullptr_003, TestSize.Level1)
1507 {
1508 OHOS::DistributedDeviceProfile::TrustProfileManager::
1509 GetInstance().rdbStore_ = nullptr;
1510
1511 std::vector<AccessControlProfile> profiles;
1512 std::map<std::string, std::string> parms;
1513 parms.insert({{"userId", "001"}, {"bundleName", "b1"}, {"trustDeviceId", "9999"}, {"status", "1"}});
1514 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1515 GetInstance().GetAccessControlProfile(parms, profiles);
1516 EXPECT_NE(ret, DP_SUCCESS);
1517
1518 parms.clear();
1519 profiles.clear();
1520 parms.insert({{"userId", "11"}, {"bundleName", "b1"}, {"bindType", "1"}, {"status", "0"}});
1521 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1522 GetInstance().GetAccessControlProfile(parms, profiles);
1523 EXPECT_NE(ret, DP_SUCCESS);
1524
1525 parms.clear();
1526 profiles.clear();
1527 parms.insert({{"bundleName", "b4"}, {"bindType", "1"}, {"status", "0"}});
1528 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1529 GetInstance().GetAccessControlProfile(parms, profiles);
1530 EXPECT_NE(ret, DP_SUCCESS);
1531
1532 parms.clear();
1533 profiles.clear();
1534 parms.insert({{"tokenId", "55555"}, {"trustDeviceId", "9999"}, {"status", "1"}});
1535 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1536 GetInstance().GetAccessControlProfile(parms, profiles);
1537 EXPECT_NE(ret, DP_SUCCESS);
1538
1539 parms.clear();
1540 profiles.clear();
1541 parms.insert({{"bundleName", "b4"}, {"trustDeviceId", "9999"}, {"status", "1"}});
1542 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1543 GetInstance().GetAccessControlProfile(parms, profiles);
1544 EXPECT_NE(ret, DP_SUCCESS);
1545
1546 parms.clear();
1547 profiles.clear();
1548 parms.insert({{"userId", "77"}, {"accountId", "a44"}});
1549 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1550 GetInstance().GetAccessControlProfile(parms, profiles);
1551 EXPECT_NE(ret, DP_SUCCESS);
1552
1553 parms.clear();
1554 profiles.clear();
1555 parms.insert({{"userId", "77"}});
1556 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1557 GetInstance().GetAccessControlProfile(parms, profiles);
1558 EXPECT_NE(ret, DP_SUCCESS);
1559 }
1560
1561 /*
1562 * @tc.name: RdbStoreIsNullptr_004
1563 * @tc.desc: Normal testCase of TrustProfileManagerTest for CRUD
1564 * @tc.type: FUNC
1565 */
1566 HWTEST_F(TrustProfileManagerTest, RdbStoreIsNullptr_004, TestSize.Level1)
1567 {
1568 OHOS::DistributedDeviceProfile::TrustProfileManager::
1569 GetInstance().rdbStore_ = nullptr;
1570
1571 AccessControlProfile profile;
1572 int32_t status = 0;
1573 int32_t ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1574 GetInstance().GetResultStatus("123", status);
1575 EXPECT_NE(ret, DP_SUCCESS);
1576
1577 std::vector<AccessControlProfile> profiles;
1578 std::shared_ptr<ResultSet> resultSet;
1579 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1580 GetInstance().GetAccessControlProfiles(resultSet, 1, 1, 1, "1", profiles);
1581 EXPECT_NE(ret, DP_SUCCESS);
1582
1583 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1584 GetInstance().GetAccessControlProfiles(resultSet, 1, 1, 1, profiles);
1585 EXPECT_NE(ret, DP_SUCCESS);
1586
1587 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1588 GetInstance().GetAccessControlProfilesByTokenId(resultSet, 1, 1, "1", 1, profiles);
1589 EXPECT_NE(ret, DP_SUCCESS);
1590
1591 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1592 GetInstance().GetAccessControlProfilesByDeviceId(resultSet, 1, 1, "1", profiles);
1593 EXPECT_NE(ret, DP_SUCCESS);
1594
1595 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1596 GetInstance().DeleteAccesserCheck(1);
1597 EXPECT_NE(ret, DP_SUCCESS);
1598
1599 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1600 GetInstance().DeleteAccesseeCheck(1);
1601 EXPECT_NE(ret, DP_SUCCESS);
1602
1603 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1604 GetInstance().UpdateAclCheck(profile);
1605 EXPECT_NE(ret, DP_SUCCESS);
1606
1607 ret = OHOS::DistributedDeviceProfile::TrustProfileManager::
1608 GetInstance().DeleteTrustDeviceCheck(profile);
1609 EXPECT_NE(ret, DP_SUCCESS);
1610 }
1611 } // namespace DistributedDeviceProfile
1612 } // namespace OHOS
1613