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