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