1 /*
2  * Copyright (c) 2022-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 "UTTest_hichain_connector.h"
17 
18 #include <cstdlib>
19 #include <ctime>
20 #include <functional>
21 #include <securec.h>
22 
23 #include "device_manager_service_listener.h"
24 #include "dm_anonymous.h"
25 #include "dm_constants.h"
26 #include "dm_credential_manager.h"
27 #include "dm_log.h"
28 #include "dm_random.h"
29 #include "parameter.h"
30 
31 namespace OHOS {
32 namespace DistributedHardware {
SetUp()33 void HichainConnectorTest::SetUp()
34 {
35 }
TearDown()36 void HichainConnectorTest::TearDown()
37 {
38 }
SetUpTestCase()39 void HichainConnectorTest::SetUpTestCase()
40 {
41 }
TearDownTestCase()42 void HichainConnectorTest::TearDownTestCase()
43 {
44 }
45 
46 class HiChainConnectorCallbackTest : public IHiChainConnectorCallback {
47 public:
HiChainConnectorCallbackTest()48     HiChainConnectorCallbackTest() {}
~HiChainConnectorCallbackTest()49     virtual ~HiChainConnectorCallbackTest() {}
OnGroupCreated(int64_t requestId,const std::string & groupId)50     void OnGroupCreated(int64_t requestId, const std::string &groupId) override
51     {
52         (void)requestId;
53         (void)groupId;
54     }
OnMemberJoin(int64_t requestId,int32_t status)55     void OnMemberJoin(int64_t requestId, int32_t status) override
56     {
57         (void)requestId;
58         (void)status;
59     }
GetConnectAddr(std::string deviceId)60     std::string GetConnectAddr(std::string deviceId)
61     {
62         return "";
63     }
GetPinCode(int32_t & code)64     int32_t GetPinCode(int32_t &code)
65     {
66         int32_t pinCode = 123456;
67         code = pinCode;
68         return DM_OK;
69     }
70 };
71 
72 namespace {
73 /**
74  * @tc.name: CreateGroup_001
75  * @tc.desc: Set the deviceGroupManager_ pointer to CreateGroup to NULlptr and return ERR_DM_INPUT_PARA_INVALID
76  * @tc.type: FUNC
77  * @tc.require: AR000GHSJK
78  */
79 HWTEST_F(HichainConnectorTest, CreateGroup_001, testing::ext::TestSize.Level0)
80 {
81     int64_t requestId = 123456;
82     std::string groupName = "dfggg";
83     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
84     hiChainConnector->deviceGroupManager_ = nullptr;
85     int ret = hiChainConnector->CreateGroup(requestId, groupName);
86     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
87 }
88 
89 /**
90  * @tc.name: CreateGroup_002
91  * @tc.desc: Set CreateGroup to the correct process and return DM_OK
92  * @tc.type: FUNC
93  * @tc.require: AR000GHSJK
94  */
95 HWTEST_F(HichainConnectorTest, CreateGroup_002, testing::ext::TestSize.Level0)
96 {
97     int64_t requestId = 123456;
98     std::string groupName = "uuiioo";
99     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
100     int ret = hiChainConnector->CreateGroup(requestId, groupName);
101     EXPECT_EQ(ret, ERR_DM_CREATE_GROUP_FAILED);
102 }
103 
104 /**
105  * @tc.name: CreateGroup_003
106  * @tc.desc: Set deviceGroupManager_ is nullptr return ERR_DM_INPUT_PARA_INVALID
107  * @tc.type: FUNC
108  * @tc.require: AR000GHSJK
109  */
110 HWTEST_F(HichainConnectorTest, CreateGroup_003, testing::ext::TestSize.Level0)
111 {
112     int64_t requestId = 159357;
113     int32_t authType = 1;
114     std::string userId = "userIdTest";
115     nlohmann::json jsonOutObj;
116     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
117     hiChainConnector->deviceGroupManager_ = nullptr;
118     int32_t ret = hiChainConnector->CreateGroup(requestId, authType, userId, jsonOutObj);
119     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
120 }
121 
122 /**
123  * @tc.name: IsGroupInfoInvalid_001
124  * @tc.desc: GroupType is GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP, group.groupVisibility is not GROUP_VISIBILITY_PUBLIC.
125              Group.return true
126  * @tc.type: FUNC
127  * @tc.require: AR000GHSJK
128  */
129 
130 HWTEST_F(HichainConnectorTest, IsGroupInfoInvalid_001, testing::ext::TestSize.Level0)
131 {
132     GroupInfo group;
133     group.groupName = "dkdkkdkdk";
134     group.groupId = 1;
135     group.groupOwner = "ohos.distributedhardware.devicemanager";
136     group.groupType = 7;
137     group.groupVisibility = 1;
138     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
139     bool ret = hiChainConnector->IsGroupInfoInvalid(group);
140     EXPECT_EQ(ret, false);
141 }
142 
143 /**
144  * @tc.name: IsGroupInfoInvalid_002
145  * @tc.desc: GroupType is GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP, group.groupVisibility is GROUP_VISIBILITY_PUBLIC,
146              Grou. groupOwner is not equal to DM_PKG_NAME. The value is true
147  * @tc.type: FUNC
148  * @tc.require: AR000GHSJK
149  */
150 HWTEST_F(HichainConnectorTest, IsGroupInfoInvalid_002, testing::ext::TestSize.Level0)
151 {
152     GroupInfo group;
153     group.groupName = "test";
154     group.groupId = 1;
155     group.groupOwner = "ohos.disware";
156     group.groupType = 1;
157     group.groupVisibility = -1;
158     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
159     bool ret = hiChainConnector->IsGroupInfoInvalid(group);
160     EXPECT_EQ(ret, true);
161 }
162 
163 /**
164  * @tc.name: DelMemberFromGroup_001
165  * @tc.desc:set groupId, deviceId null and return DM_OK
166  * @tc.type: FUNC
167  * @tc.require: AR000GHSJK
168  */
169 HWTEST_F(HichainConnectorTest, DelMemberFromGroup_001, testing::ext::TestSize.Level0)
170 {
171     std::string groupId;
172     std::string deviceId;
173     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
174     int ret = hiChainConnector->DelMemberFromGroup(groupId, deviceId);
175     EXPECT_NE(ret, -1);
176 }
177 
178 /**
179  * @tc.name: DelMemberFromGroup_002
180  * @tc.desc: The groupId "34451"; The deviceId = "123"; Can be deleted correctly
181  * @tc.type: FUNC
182  * @tc.require: AR000GHSJK
183  */
184 HWTEST_F(HichainConnectorTest, DelMemberFromGroup_002, testing::ext::TestSize.Level0)
185 {
186     std::string groupId = "34451";
187     std::string deviceId = "123";
188     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
189     int ret = hiChainConnector->DelMemberFromGroup(groupId, deviceId);
190     EXPECT_NE(ret, -1);
191 }
192 
193 /**
194  * @tc.name: GenRequestId_001
195  * @tc.desc:Call the GenRequestId function
196  * @tc.type: FUNC
197  * @tc.require: AR000GHSJK
198  */
199 HWTEST_F(HichainConnectorTest, GenRequestId_001, testing::ext::TestSize.Level0)
200 {
201     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
202     int ret = hiChainConnector->GenRequestId();
203     ASSERT_NE(ret, 0);
204 }
205 
206 /**
207  * @tc.name: from_json_001
208  * @tc.desc: Pass in arguments to the from_JSON function and convert it to the correct value
209  * @tc.type: FUNC
210  * @tc.require: AR000GHSJK
211  */
212 HWTEST_F(HichainConnectorTest, from_json_001, testing::ext::TestSize.Level0)
213 {
214     GroupInfo groupInfo;
215     groupInfo.groupName = "aaaa";
216     groupInfo.groupId = "345678";
217     groupInfo.groupOwner = "lllll";
218     groupInfo.groupType = 5;
219     groupInfo.groupVisibility = 5;
220     nlohmann::json jsonObject;
221     jsonObject[FIELD_GROUP_NAME] = groupInfo.groupName;
222     jsonObject[FIELD_GROUP_ID] = groupInfo.groupId;
223     jsonObject[FIELD_GROUP_OWNER] = groupInfo.groupOwner;
224     jsonObject[FIELD_GROUP_TYPE] = groupInfo.groupType;
225     jsonObject[FIELD_GROUP_VISIBILITY] = groupInfo.groupVisibility;
226     from_json(jsonObject, groupInfo);
227     EXPECT_EQ(groupInfo.groupName, "aaaa");
228     EXPECT_EQ(groupInfo.groupId, "345678");
229     EXPECT_EQ(groupInfo.groupOwner, "lllll");
230     EXPECT_EQ(groupInfo.groupType, 5);
231     EXPECT_EQ(groupInfo.groupVisibility, 5);
232 }
233 
234 /**
235  * @tc.name: from_json_002
236  * @tc.desc: Pass in arguments to the from_JSON function and convert it to the correct value
237  * @tc.type: FUNC
238  * @tc.require: AR000GHSJK
239  */
240 HWTEST_F(HichainConnectorTest, from_json_002, testing::ext::TestSize.Level0)
241 {
242     GroupInfo groupInfo;
243     groupInfo.userId = "test";
244     groupInfo.groupName = "test";
245     nlohmann::json jsonObject;
246     jsonObject[FIELD_GROUP_NAME] = 0;
247     jsonObject[FIELD_GROUP_ID] = 0;
248     jsonObject[FIELD_GROUP_OWNER] = 0;
249     jsonObject[FIELD_GROUP_TYPE] = "test";
250     jsonObject[FIELD_GROUP_VISIBILITY] = "test";
251     jsonObject[FIELD_USER_ID] = "userId";
252     from_json(jsonObject, groupInfo);
253     EXPECT_EQ(groupInfo.userId, "userId");
254 
255     jsonObject[FIELD_USER_ID] = "0";
256     jsonObject.erase(FIELD_GROUP_NAME);
257     jsonObject.erase(FIELD_GROUP_ID);
258     jsonObject.erase(FIELD_GROUP_OWNER);
259     jsonObject.erase(FIELD_GROUP_TYPE);
260     jsonObject.erase(FIELD_GROUP_VISIBILITY);
261     from_json(jsonObject, groupInfo);
262     EXPECT_EQ(groupInfo.groupName, "test");
263 }
264 
265 /**
266  * @tc.name: HiChainConnector_001
267  * @tc.desc: Returns a new pointer to the HiChainConnector constructor new
268  * @tc.type: FUNC
269  * @tc.require: AR000GHSJK
270  */
271 HWTEST_F(HichainConnectorTest, HiChainConnector_001, testing::ext::TestSize.Level0)
272 {
273     std::shared_ptr<HiChainConnector> m_HiChainConnector = std::make_shared<HiChainConnector>();
274     ASSERT_NE(m_HiChainConnector, nullptr);
275 }
276 
277 /**
278  * @tc.name: HiChainConnector_002
279  * @tc.desc: Give the HiChainConnector constructor new a new pointer and delete it
280  * @tc.type: FUNC
281  * @tc.require: AR000GHSJK
282  */
283 HWTEST_F(HichainConnectorTest, HiChainConnector_002, testing::ext::TestSize.Level0)
284 {
285     std::shared_ptr<HiChainConnector> m_HiChainConnector = std::make_shared<HiChainConnector>();
286     m_HiChainConnector.reset();
287     EXPECT_EQ(m_HiChainConnector, nullptr);
288 }
289 
290 /**
291  * @tc.name:RegisterHiChainCallback_001
292  * @tc.desc: Call the RegisterHiChainCallback function with a return value of DM_OK
293  * @tc.type: FUNC
294  * @tc.require: AR000GHSJK
295  */
296 HWTEST_F(HichainConnectorTest, RegisterHiChainCallback_001, testing::ext::TestSize.Level0)
297 {
298     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
299     int ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
300     EXPECT_EQ(ret, DM_OK);
301 }
302 
303 /**
304  * @tc.name: AddMember_001
305  * @tc.desc: set deviceGroupManager_ = nullptr;
306  * @tc.type: FUNC
307  * @tc.require: AR000GHSJK
308  */
309 HWTEST_F(HichainConnectorTest, AddMember_001, testing::ext::TestSize.Level0)
310 {
311     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
312     hiChainConnector->deviceGroupManager_ = nullptr;
313     std::string deviceId;
314     std::string connectInfo;
315     int ret = hiChainConnector->AddMember(deviceId, connectInfo);
316     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
317 }
318 
319 /**
320  * @tc.name: AddMember_002
321  * @tc.desc: set deviceId and connectInfo = null;
322  * @tc.type: FUNC
323  * @tc.require: AR000GHSJK
324  */
325 HWTEST_F(HichainConnectorTest, AddMember_002, testing::ext::TestSize.Level0)
326 {
327     std::string deviceId;
328     std::string connectInfo;
329     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
330     int ret = hiChainConnector->AddMember(deviceId, connectInfo);
331     EXPECT_EQ(ret, ERR_DM_FAILED);
332 }
333 
334 /**
335  * @tc.name: AddMember_003
336  * @tc.desc: set deviceId and connectInfo = null;
337  * @tc.type: FUNC
338  * @tc.require: AR000GHSJK
339  */
340 HWTEST_F(HichainConnectorTest, AddMember_003, testing::ext::TestSize.Level0)
341 {
342     std::string deviceId = "123456";
343     std::string connectInfo = "dkdkk";
344     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
345     int ret = hiChainConnector->AddMember(deviceId, connectInfo);
346     ASSERT_EQ(ret, ERR_DM_FAILED);
347 }
348 
349 /**
350  * @tc.name: AddMember_004
351  * @tc.desc: set deviceId and connectInfo = null;
352  * @tc.type: FUNC
353  * @tc.require: AR000GHSJK
354  */
355 HWTEST_F(HichainConnectorTest, AddMember_004, testing::ext::TestSize.Level0)
356 {
357     std::string deviceId = "deviceIdTest";
358     std::string connectInfo = R"(
359     {
360         "DEVICEID" : "deviceId",
361         "pinCode" : 1,
362         "groupId" : "groupId",
363         "REQUESTID" : "requestId",
364         "GROUPNAME" : "groupName"
365     }
366     )";
367     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
368     int32_t ret = hiChainConnector->AddMember(deviceId, connectInfo);
369     EXPECT_EQ(ret, ERR_DM_FAILED);
370 }
371 
372 /**
373  * @tc.name: onRequest_001
374  * @tc.desc:set operationCode != GroupOperationCode::MEMBER_JOIN(3);  return nullptr;
375  * @tc.require: AR000GHSJK
376  */
377 HWTEST_F(HichainConnectorTest, onRequest_001, testing::ext::TestSize.Level0)
378 {
379     int64_t requestId = 2;
380     int32_t operationCode = 2;
381     char *reqParams;
382     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
383     char *ret = hiChainConnector->onRequest(requestId, operationCode, reqParams);
384     EXPECT_EQ(ret, nullptr);
385 }
386 
387 /**
388  * @tc.name: onRequest_002
389  * @tc.desc: operationCode = GroupOperationCode::MEMBER_JOIN(3)/hiChainConnectorCallback_ is nullptr; return nullptr;
390  * @tc.require: AR000GHSJK
391  */
392 HWTEST_F(HichainConnectorTest, onRequest_002, testing::ext::TestSize.Level0)
393 {
394     int64_t requestId = 2;
395     int32_t operationCode = 3;
396     char *reqParams;
397     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
398     hiChainConnector->hiChainConnectorCallback_ = nullptr;
399     char *ret = hiChainConnector->onRequest(requestId, operationCode, reqParams);
400     EXPECT_EQ(ret, nullptr);
401 }
402 
403 /**
404  * @tc.name: onRequest_003
405  * @tc.desc: Test the onRequest method of HiChainConnector to ensure it handles different
406  *           return values from GetPinCode correctly.
407  * @tc.require: AR000GHSJK
408  */
409 HWTEST_F(HichainConnectorTest, onRequest_003, testing::ext::TestSize.Level0)
410 {
411     int64_t requestId = 2;
412     int32_t operationCode = 3;
413     char *reqParams = nullptr;
414     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
415     std::shared_ptr<MockIHiChainConnectorCallback> mockCallback = std::make_shared<MockIHiChainConnectorCallback>();
416     hiChainConnector->hiChainConnectorCallback_ = mockCallback;
417     EXPECT_CALL(*mockCallback, GetPinCode(testing::_))
418         .Times(1)
419         .WillOnce(testing::Return(ERR_DM_FAILED));
420     EXPECT_NE(hiChainConnector->onRequest(requestId, operationCode, reqParams), nullptr);
421 
422     EXPECT_CALL(*mockCallback, GetPinCode(testing::_))
423         .Times(1)
424         .WillOnce(testing::Return(DM_OK));
425     EXPECT_NE(hiChainConnector->onRequest(requestId, operationCode, reqParams), nullptr);
426 }
427 
428 /**
429  * @tc.name: GetConnectPara_001
430  * @tc.desc: Test GetConnectPara method when hiChainConnectorCallback_ is set to nullptr,
431  *           ensuring it returns an empty string.
432  * @tc.type: FUNC
433  * @tc.require: AR000GHSJK
434  */
435 HWTEST_F(HichainConnectorTest, GetConnectPara_001, testing::ext::TestSize.Level0)
436 {
437     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
438     hiChainConnector->hiChainConnectorCallback_ = nullptr;
439     std::string deviceId = "12345";
440     std::string reqDeviceId = "12345";
441     std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
442     EXPECT_EQ(ret, "");
443 }
444 
445 /**
446  * @tc.name: GetConnectPara_002
447  * @tc.desc: Test GetConnectPara method with an empty deviceId to ensure JSON parsing fails
448  *           and returns an empty string.
449  * @tc.type: FUNC
450  * @tc.require: AR000GHSJK
451  */
452 HWTEST_F(HichainConnectorTest, GetConnectPara_002, testing::ext::TestSize.Level0)
453 {
454     std::string deviceId;
455     std::string reqDeviceId = "12345";
456     std::shared_ptr<MockIHiChainConnectorCallback> mockCallback = std::make_shared<MockIHiChainConnectorCallback>();
457     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
458     hiChainConnector->hiChainConnectorCallback_ = mockCallback;
459     EXPECT_CALL(*mockCallback, GetConnectAddr(testing::_))
460         .Times(1)
461         .WillOnce(testing::Return(R"({"key": "value"})"));
462     std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
463     EXPECT_NE(ret, "");
464 }
465 
466 /**
467  * @tc.name: GetConnectPara_003
468  * @tc.desc: Test GetConnectPara method with invalid JSON returned by hiChainConnectorCallback_
469  *           to ensure it returns an empty string.
470  * @tc.type: FUNC
471  * @tc.require: AR000GHSJK
472  */
473 HWTEST_F(HichainConnectorTest, GetConnectPara_003, testing::ext::TestSize.Level0)
474 {
475     std::string deviceId;
476     std::string reqDeviceId = "12345";
477     std::shared_ptr<MockIHiChainConnectorCallback> mockCallback = std::make_shared<MockIHiChainConnectorCallback>();
478     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
479     hiChainConnector->hiChainConnectorCallback_ = mockCallback;
480     EXPECT_CALL(*mockCallback, GetConnectAddr(testing::_))
481         .Times(1)
482         .WillOnce(testing::Return("invalid json"));
483     std::string ret = hiChainConnector->GetConnectPara(deviceId, reqDeviceId);
484     EXPECT_EQ(ret, "invalid json");
485 }
486 
487 /**
488  * @tc.name: DeleteGroup_001
489  * @tc.desc: set groupId = "34567", and return ERR_DM_FAILED
490  * @tc.type: FUNC
491  * @tc.require: AR000GHSJK
492  */
493 HWTEST_F(HichainConnectorTest, DeleteGroup_001, testing::ext::TestSize.Level0)
494 {
495     std::string groupId = "34567";
496     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
497     int ret = hiChainConnector->DeleteGroup(groupId);
498     EXPECT_EQ(ret, ERR_DM_FAILED);
499 }
500 
501 /**
502  * @tc.name: GetRelatedGroups_001
503  * @tc.desc: set DeviceId 123  groupList null and return ERR_DM_FAILED
504  * @tc.type: FUNC
505  * @tc.require: AR000GHSJK
506  */
507 HWTEST_F(HichainConnectorTest, GetRelatedGroups_001, testing::ext::TestSize.Level0)
508 {
509     std::string deviceId = "123";
510     std::vector<GroupInfo> groupList;
511     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
512     int ret = hiChainConnector->GetRelatedGroups(deviceId, groupList);
513     EXPECT_EQ(ret, ERR_DM_FAILED);
514 }
515 
516 /**
517  * @tc.name: GetRelatedGroupsExt_001
518  * @tc.desc: set DeviceId = 12345,groupList null and return ERR_DM_FAILED
519  * @tc.type: FUNC
520  * @tc.require: AR000GHSJK
521  */
522 HWTEST_F(HichainConnectorTest, GetRelatedGroupsExt_001, testing::ext::TestSize.Level0)
523 {
524     std::string deviceId = "12345";
525     std::vector<GroupInfo> groupList;
526     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
527     int ret = hiChainConnector->GetRelatedGroupsExt(deviceId, groupList);
528     EXPECT_EQ(ret, ERR_DM_FAILED);
529 }
530 
531 /**
532  * @tc.name: SyncGroups_001
533  * @tc.desc: set deviceId = "34567", and return DM_OK
534  * @tc.type: FUNC
535  * @tc.require: AR000GHSJK
536  */
537 HWTEST_F(HichainConnectorTest, SyncGroups_001, testing::ext::TestSize.Level0)
538 {
539     std::string deviceId = "34567";
540     std::vector<std::string> remoteGroupIdList;
541     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
542     int ret = hiChainConnector->SyncGroups(deviceId, remoteGroupIdList);
543     EXPECT_EQ(ret, DM_OK);
544 }
545 
546 /**
547  * @tc.name: GetSyncGroupList_001
548  * @tc.desc: set groupList null, and return ERR_DM_FAILED
549  * @tc.type: FUNC
550  * @tc.require: AR000GHSJK
551  */
552 HWTEST_F(HichainConnectorTest, GetSyncGroupList_001, testing::ext::TestSize.Level0)
553 {
554     std::vector<GroupInfo> groupList;
555     std::vector<std::string> syncGroupList;
556     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
557     int ret = hiChainConnector->GetSyncGroupList(groupList, syncGroupList);
558     EXPECT_EQ(ret, ERR_DM_FAILED);
559 }
560 
561 /**
562  * @tc.name: GetSyncGroupList_002
563  * @tc.desc: set groupList not null, and return DM_OK
564  * @tc.type: FUNC
565  * @tc.require: AR000GHSJK
566  */
567 HWTEST_F(HichainConnectorTest, GetSyncGroupList_002, testing::ext::TestSize.Level0)
568 {
569     std::vector<GroupInfo> groupList;
570     GroupInfo groupList1;
571     groupList1.groupName = "groupName";
572     groupList1.groupId = 1;
573     groupList1.groupOwner = "ohos.distributedhardware.devicemanager";
574     groupList1.groupType = 7;
575     groupList1.groupVisibility = 1;
576     groupList.push_back(groupList1);
577     GroupInfo groupList2;
578     groupList2.groupName = "hichainconnector";
579     groupList2.groupId = "123456";
580     groupList2.groupOwner = "doftbus";
581     groupList2.groupType = 1;
582     groupList2.groupVisibility = 2;
583     groupList.push_back(groupList2);
584     std::vector<std::string> syncGroupList;
585     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
586     int ret = hiChainConnector->GetSyncGroupList(groupList, syncGroupList);
587     EXPECT_EQ(ret, DM_OK);
588 }
589 
590 /**
591  * @tc.name: IsGroupCreated_001
592  * @tc.desc: return false
593  * @tc.type: FUNC
594  * @tc.require: AR000GHSJK
595  */
596 HWTEST_F(HichainConnectorTest, IsGroupCreated_001, testing::ext::TestSize.Level0)
597 {
598     std::string groupName = "groupNameTest";
599     GroupInfo groupInfo;
600     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
601     bool ret = hiChainConnector->IsGroupCreated(groupName, groupInfo);
602     EXPECT_EQ(ret, false);
603 }
604 
605 /**
606  * @tc.name: IsRedundanceGroup_001
607  * @tc.desc: return false
608  * @tc.type: FUNC
609  * @tc.require: AR000GHSJK
610  */
611 HWTEST_F(HichainConnectorTest, IsRedundanceGroup_001, testing::ext::TestSize.Level0)
612 {
613     const std::string userId = "userIdTest";
614     int32_t authType = 1;
615     std::vector<GroupInfo> groupList;
616     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
617     bool ret = hiChainConnector->IsRedundanceGroup(userId, authType, groupList);
618     EXPECT_EQ(ret, false);
619 }
620 
621 /**
622  * @tc.name: onFinish_001
623  * @tc.desc: return DM_OK
624  * @tc.type: FUNC
625  * @tc.require: AR000GHSJK
626  */
627 HWTEST_F(HichainConnectorTest, onFinish_001, testing::ext::TestSize.Level0)
628 {
629     int64_t requestId = 1;
630     int operationCode = GroupOperationCode::MEMBER_JOIN;
631     const char *returnData = "returnDataTest";
632     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
633     int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
634 
635     hiChainConnector->onFinish(requestId, operationCode, returnData);
636 
637     operationCode = GroupOperationCode::GROUP_CREATE;
638     hiChainConnector->onFinish(requestId, operationCode, returnData);
639 
640     operationCode = GroupOperationCode::MEMBER_DELETE;
641     hiChainConnector->onFinish(requestId, operationCode, returnData);
642 
643     operationCode = GroupOperationCode::GROUP_DISBAND;
644     hiChainConnector->onFinish(requestId, operationCode, returnData);
645     EXPECT_EQ(ret, DM_OK);
646 }
647 
648 /**
649  * @tc.name: onFinish_002
650  * @tc.desc: return DM_OK
651  * @tc.type: FUNC
652  * @tc.require: AR000GHSJK
653  */
654 HWTEST_F(HichainConnectorTest, onFinish_002, testing::ext::TestSize.Level0)
655 {
656     int64_t requestId = 1;
657     int operationCode = GroupOperationCode::MEMBER_JOIN;
658     const char *returnData = "returnDataTest";
659     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
660     int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
661     EXPECT_EQ(ret, DM_OK);
662     ret = hiChainConnector->UnRegisterHiChainCallback();
663     EXPECT_EQ(ret, DM_OK);
664 
665     hiChainConnector->onFinish(requestId, operationCode, returnData);
666 
667     operationCode = GroupOperationCode::GROUP_CREATE;
668     hiChainConnector->onFinish(requestId, operationCode, returnData);
669 
670     hiChainConnector->networkStyle_ = 1;
671     hiChainConnector->hiChainResCallback_ = nullptr;
672     hiChainConnector->onFinish(requestId, operationCode, returnData);
673 
674     std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
675     std::shared_ptr<HiChainConnector> hiChainConn = std::make_shared<HiChainConnector>();
676     hiChainConnector->hiChainResCallback_ = std::make_shared<DmCredentialManager>(hiChainConn, listener);
677     hiChainConnector->onFinish(requestId, operationCode, returnData);
678 
679     operationCode = GroupOperationCode::GROUP_DISBAND;
680     hiChainConnector->onFinish(requestId, operationCode, returnData);
681 
682     hiChainConnector->hiChainResCallback_ = nullptr;
683     hiChainConnector->onFinish(requestId, operationCode, returnData);
684 
685     EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
686 }
687 
688 /**
689  * @tc.name: onError_001
690  * @tc.desc: return DM_OK
691  * @tc.type: FUNC
692  * @tc.require: AR000GHSJK
693  */
694 HWTEST_F(HichainConnectorTest, onError_001, testing::ext::TestSize.Level0)
695 {
696     int64_t requestId = 1;
697     int operationCode = GroupOperationCode::MEMBER_JOIN;
698     int errorCode = 1;
699     const char *errorReturn = "errorReturnTest";
700     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
701     int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
702     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
703 
704     operationCode = GroupOperationCode::GROUP_CREATE;
705     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
706 
707     operationCode = GroupOperationCode::MEMBER_DELETE;
708     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
709 
710     operationCode = GroupOperationCode::GROUP_DISBAND;
711     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
712     EXPECT_EQ(ret, DM_OK);
713 }
714 
715 /**
716  * @tc.name: onError_002
717  * @tc.desc: return DM_OK
718  * @tc.type: FUNC
719  * @tc.require: AR000GHSJK
720  */
721 HWTEST_F(HichainConnectorTest, onError_002, testing::ext::TestSize.Level0)
722 {
723     int64_t requestId = 1;
724     int operationCode = GroupOperationCode::MEMBER_JOIN;
725     int errorCode = 1;
726     const char *errorReturn = "errorReturnTest";
727     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
728     int32_t ret = hiChainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
729     EXPECT_EQ(ret, DM_OK);
730     ret = hiChainConnector->UnRegisterHiChainCallback();
731     EXPECT_EQ(ret, DM_OK);
732     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
733 
734     operationCode = GroupOperationCode::GROUP_CREATE;
735     hiChainConnector->networkStyle_ = 0;
736     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
737 
738     hiChainConnector->networkStyle_ = 1;
739     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
740 
741     std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
742     std::shared_ptr<HiChainConnector> hiChainConn = std::make_shared<HiChainConnector>();
743     hiChainConnector->hiChainResCallback_ = std::make_shared<DmCredentialManager>(hiChainConn, listener);
744     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
745 
746     operationCode = GroupOperationCode::GROUP_DISBAND;
747     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
748 
749     hiChainConnector->hiChainResCallback_ = nullptr;
750     hiChainConnector->onError(requestId, operationCode, errorCode, errorReturn);
751     EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
752 }
753 
754 /**
755  * @tc.name: DeleteGroup_002
756  * @tc.desc: return ERR_DM_FAILED
757  * @tc.type: FUNC
758  * @tc.require: AR000GHSJK
759  */
760 HWTEST_F(HichainConnectorTest, DeleteGroup_002, testing::ext::TestSize.Level0)
761 {
762     const int32_t userId = 1;
763     std::string groupId = "groupIdTest";
764     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
765     int32_t ret = hiChainConnector->DeleteGroup(userId, groupId);
766     EXPECT_EQ(ret, ERR_DM_FAILED);
767 }
768 
769 /**
770  * @tc.name: DeleteGroup_003
771  * @tc.desc: return ERR_DM_FAILED
772  * @tc.type: FUNC
773  * @tc.require: AR000GHSJK
774  */
775 HWTEST_F(HichainConnectorTest, DeleteGroup_003, testing::ext::TestSize.Level0)
776 {
777     int64_t requestId = 1;
778     std::string userId = "userIdTest";
779     const int32_t authType = 1;
780     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
781     hiChainConnector->DeleteRedundanceGroup(userId);
782     int32_t ret = hiChainConnector->DeleteGroup(requestId, userId, authType);
783     EXPECT_EQ(ret, ERR_DM_FAILED);
784 }
785 
786 /**
787  * @tc.name: RegisterHiChainGroupCallback_001
788  * @tc.desc: return DM_OK
789  * @tc.type: FUNC
790  * @tc.require: AR000GHSJK
791  */
792 HWTEST_F(HichainConnectorTest, RegisterHiChainGroupCallback_001, testing::ext::TestSize.Level0)
793 {
794     std::shared_ptr<IDmGroupResCallback> callback = nullptr;
795     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
796     int32_t ret = hiChainConnector->RegisterHiChainGroupCallback(callback);
797     EXPECT_EQ(ret, DM_OK);
798 }
799 
800 /**
801  * @tc.name: UnRegisterHiChainGroupCallback_001
802  * @tc.desc: return DM_OK
803  * @tc.type: FUNC
804  * @tc.require: AR000GHSJK
805  */
806 HWTEST_F(HichainConnectorTest, UnRegisterHiChainGroupCallback_001, testing::ext::TestSize.Level0)
807 {
808     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
809     int32_t ret = hiChainConnector->UnRegisterHiChainGroupCallback();
810     EXPECT_EQ(ret, DM_OK);
811 }
812 
813 /**
814  * @tc.name: getRegisterInfo_001
815  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
816  * @tc.type: FUNC
817  * @tc.require: AR000GHSJK
818  */
819 HWTEST_F(HichainConnectorTest, getRegisterInfo_001, testing::ext::TestSize.Level0)
820 {
821     std::string queryParams;
822     std::string returnJsonStr;
823     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
824     hiChainConnector->deviceGroupManager_ = nullptr;
825     int32_t ret = hiChainConnector->getRegisterInfo(queryParams, returnJsonStr);
826     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
827 }
828 
829 /**
830  * @tc.name: getRegisterInfo_002
831  * @tc.desc: return ERR_DM_FAILED
832  * @tc.type: FUNC
833  * @tc.require: AR000GHSJK
834  */
835 HWTEST_F(HichainConnectorTest, getRegisterInfo_002, testing::ext::TestSize.Level0)
836 {
837     std::string queryParams;
838     std::string returnJsonStr;
839     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
840     int32_t ret = hiChainConnector->getRegisterInfo(queryParams, returnJsonStr);
841     EXPECT_EQ(ret, ERR_DM_FAILED);
842 }
843 
844 /**
845  * @tc.name: ParseRemoteCredential_001
846  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
847  * @tc.type: FUNC
848  * @tc.require: AR000GHSJK
849  */
850 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_001, testing::ext::TestSize.Level0)
851 {
852     int32_t groupType = 1;
853     std::string userId;
854     nlohmann::json jsonDeviceList;
855     std::string params = "paramsTest";
856     int32_t osAccountUserId = 0;
857     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
858     int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
859     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
860 }
861 
862 /**
863  * @tc.name: ParseRemoteCredential_002
864  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
865  * @tc.type: FUNC
866  * @tc.require: AR000GHSJK
867  */
868 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_002, testing::ext::TestSize.Level0)
869 {
870     int32_t groupType = 1;
871     std::string userId = "1321231";
872     nlohmann::json jsonDeviceList;
873     std::string params = "paramsTest";
874     int32_t osAccountUserId = 0;
875     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
876     int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
877     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
878 }
879 
880 /**
881  * @tc.name: ParseRemoteCredential_003
882  * @tc.desc: return ERR_DM_FAILED
883  * @tc.type: FUNC
884  * @tc.require: AR000GHSJK
885  */
886 HWTEST_F(HichainConnectorTest, ParseRemoteCredential_003, testing::ext::TestSize.Level0)
887 {
888     int32_t groupType = 1;
889     std::string userId = "1321231";
890     nlohmann::json jsonDeviceList;
891     jsonDeviceList[FIELD_DEVICE_LIST] = "15264646";
892     std::string params = "paramsTest";
893     int32_t osAccountUserId = 0;
894     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
895     int32_t ret = hiChainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
896     EXPECT_EQ(ret, ERR_DM_FAILED);
897 }
898 
899 /**
900  * @tc.name: addMultiMembers_001
901  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
902  * @tc.type: FUNC
903  * @tc.require: AR000GHSJK
904  */
905 HWTEST_F(HichainConnectorTest, addMultiMembers_001, testing::ext::TestSize.Level0)
906 {
907     int32_t groupType = 1;
908     std::string userId = "";
909     nlohmann::json jsonDeviceList;
910     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
911     hiChainConnector->deviceGroupManager_ = nullptr;
912     int32_t ret = hiChainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
913     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
914 }
915 
916 /**
917  * @tc.name: addMultiMembers_002
918  * @tc.desc: return ERR_DM_FAILED
919  * @tc.type: FUNC
920  * @tc.require: AR000GHSJK
921  */
922 HWTEST_F(HichainConnectorTest, addMultiMembers_002, testing::ext::TestSize.Level0)
923 {
924     int32_t groupType = 1;
925     std::string userId = "userIdTest";
926     nlohmann::json jsonDeviceList;
927     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
928     EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
929     int32_t ret = hiChainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
930     EXPECT_EQ(ret, ERR_DM_FAILED);
931 }
932 
933 /**
934  * @tc.name: deleteMultiMembers_001
935  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
936  * @tc.type: FUNC
937  * @tc.require: AR000GHSJK
938  */
939 HWTEST_F(HichainConnectorTest, deleteMultiMembers_001, testing::ext::TestSize.Level0)
940 {
941     int32_t groupType = 1;
942     std::string userId = "userIdTest";
943     nlohmann::json jsonDeviceList;
944     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
945     hiChainConnector->deviceGroupManager_ = nullptr;
946     int32_t ret = hiChainConnector->deleteMultiMembers(groupType, userId, jsonDeviceList);
947     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
948 }
949 
950 /**
951  * @tc.name: deleteMultiMembers_002
952  * @tc.desc: return ERR_DM_FAILED
953  * @tc.type: FUNC
954  * @tc.require: AR000GHSJK
955  */
956 HWTEST_F(HichainConnectorTest, deleteMultiMembers_002, testing::ext::TestSize.Level0)
957 {
958     int32_t groupType = 1;
959     std::string userId = "";
960     nlohmann::json jsonDeviceList;
961     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
962     EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
963     int32_t ret = hiChainConnector->deleteMultiMembers(groupType, userId, jsonDeviceList);
964     EXPECT_EQ(ret, ERR_DM_FAILED);
965 }
966 
967 /**
968  * @tc.name: IsDevicesInP2PGroup_001
969  * @tc.desc: return false
970  * @tc.type: FUNC
971  * @tc.require: AR000GHSJK
972  */
973 HWTEST_F(HichainConnectorTest, IsDevicesInP2PGroup_001, testing::ext::TestSize.Level0)
974 {
975     std::string hostDevice = "hostDeviceTest";
976     std::string peerDevice = "peerDeviceTest";
977     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
978     bool ret = hiChainConnector->IsDevicesInP2PGroup(hostDevice, peerDevice);
979     EXPECT_EQ(ret, false);
980 }
981 
982 /**
983  * @tc.name: UnRegisterHiChainCallback_001
984  * @tc.desc: return DM_OK
985  * @tc.type: FUNC
986  * @tc.require: AR000GHSJK
987  */
988 HWTEST_F(HichainConnectorTest, UnRegisterHiChainCallback_001, testing::ext::TestSize.Level0)
989 {
990     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
991     int32_t ret = hiChainConnector->UnRegisterHiChainCallback();
992     EXPECT_EQ(hiChainConnector->hiChainConnectorCallback_, nullptr);
993     EXPECT_EQ(ret, DM_OK);
994 }
995 
996 /**
997  * @tc.name: GetGroupInfo_001
998  * @tc.desc: return false
999  * @tc.type: FUNC
1000  * @tc.require: AR000GHSJK
1001  */
1002 HWTEST_F(HichainConnectorTest, GetGroupInfo_001, testing::ext::TestSize.Level0)
1003 {
1004     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1005     std::string queryParams;
1006     std::vector<GroupInfo> groupList;
1007     bool ret = hiChainConnector->GetGroupInfo(queryParams, groupList);
1008     EXPECT_EQ(ret, false);
1009 }
1010 
1011 /**
1012  * @tc.name: GetGroupInfo_002
1013  * @tc.desc: return DM_OK
1014  * @tc.type: FUNC
1015  * @tc.require: AR000GHSJK
1016  */
1017 HWTEST_F(HichainConnectorTest, GetGroupInfo_002, testing::ext::TestSize.Level0)
1018 {
1019     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1020     int32_t userId = 12;
1021     std::string queryParams;
1022     std::vector<GroupInfo> groupList;
1023     int32_t ret = hiChainConnector->GetGroupInfo(userId, queryParams, groupList);
1024     EXPECT_EQ(ret, DM_OK);
1025 }
1026 
1027 /**
1028  * @tc.name: GetGroupType_001
1029  * @tc.desc: return DM_OK
1030  * @tc.type: FUNC
1031  * @tc.require: AR000GHSJK
1032  */
1033 HWTEST_F(HichainConnectorTest, GetGroupType_001, testing::ext::TestSize.Level0)
1034 {
1035     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1036     std::string deviceId;
1037     auto ret = hiChainConnector->GetGroupType(deviceId);
1038     EXPECT_EQ(ret, DmAuthForm::INVALID_TYPE);
1039 }
1040 
1041 /**
1042  * @tc.name: DeleteGroupExt_001
1043  * @tc.desc: set groupId = "34567", and return ERR_DM_FAILED
1044  * @tc.type: FUNC
1045  * @tc.require: AR000GHSJK
1046  */
1047 HWTEST_F(HichainConnectorTest, DeleteGroupExt_001, testing::ext::TestSize.Level0)
1048 {
1049     std::string groupId = "34567";
1050     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1051     int ret = hiChainConnector->DeleteGroupExt(groupId);
1052     EXPECT_EQ(ret, ERR_DM_FAILED);
1053 }
1054 
1055 /**
1056  * @tc.name: DeleteTimeOutGroup_001
1057  * @tc.desc: return DM_OK
1058  * @tc.type: FUNC
1059  * @tc.require: AR000GHSJK
1060  */
1061 HWTEST_F(HichainConnectorTest, DeleteTimeOutGroup_001, testing::ext::TestSize.Level0)
1062 {
1063     std::string deviceId = "13245631";
1064     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1065     int ret = hiChainConnector->DeleteTimeOutGroup(deviceId.c_str());
1066     EXPECT_EQ(ret, DM_OK);
1067 }
1068 
1069 /**
1070  * @tc.name: DealRedundanceGroup_001
1071  * @tc.type: FUNC
1072  * @tc.require: AR000GHSJK
1073  */
1074 HWTEST_F(HichainConnectorTest, DealRedundanceGroup_001, testing::ext::TestSize.Level0)
1075 {
1076     std::string userId = "13245631";
1077     int32_t authType = 1;
1078     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1079     hiChainConnector->DealRedundanceGroup(userId, authType);
1080     EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
1081 }
1082 
1083 /**
1084  * @tc.name: GetGroupId_001
1085  * @tc.desc: return ERR_DM_FAILED
1086  * @tc.type: FUNC
1087  * @tc.require: AR000GHSJK
1088  */
1089 HWTEST_F(HichainConnectorTest, GetGroupId_001, testing::ext::TestSize.Level0)
1090 {
1091     std::string userId = "13245631";
1092     int32_t authType = 1;
1093     std::string groupId = "232310";
1094     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1095     int32_t ret = hiChainConnector->GetGroupId(userId, authType, groupId);
1096     EXPECT_EQ(ret, ERR_DM_FAILED);
1097 }
1098 
1099 /**
1100  * @tc.name: GetJsonStr_001
1101  * @tc.desc: return true
1102  * @tc.type: FUNC
1103  * @tc.require: AR000GHSJK
1104  */
1105 HWTEST_F(HichainConnectorTest, GetJsonStr_001, testing::ext::TestSize.Level0)
1106 {
1107     nlohmann::json jsonObj;
1108     std::string key;
1109     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1110     auto ret = hiChainConnector->GetJsonStr(jsonObj, key);
1111     EXPECT_EQ(ret.empty(), true);
1112 }
1113 
1114 /**
1115  * @tc.name: GetJsonStr_002
1116  * @tc.desc: return false
1117  * @tc.type: FUNC
1118  * @tc.require: AR000GHSJK
1119  */
1120 HWTEST_F(HichainConnectorTest, GetJsonStr_002, testing::ext::TestSize.Level0)
1121 {
1122     std::string key = "key";
1123     nlohmann::json jsonObj;
1124     jsonObj[key] = "232513";
1125     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1126     auto ret = hiChainConnector->GetJsonStr(jsonObj, key);
1127     EXPECT_EQ(ret.empty(), false);
1128 }
1129 
1130 /**
1131  * @tc.name: GetJsonInt_001
1132  * @tc.desc: return ERR_DM_FAILED
1133  * @tc.type: FUNC
1134  * @tc.require: AR000GHSJK
1135  */
1136 HWTEST_F(HichainConnectorTest, GetJsonInt_001, testing::ext::TestSize.Level0)
1137 {
1138     nlohmann::json jsonObj;
1139     std::string key;
1140     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1141     int32_t ret = hiChainConnector->GetJsonInt(jsonObj, key);
1142     EXPECT_EQ(ret, ERR_DM_FAILED);
1143 }
1144 
1145 /**
1146  * @tc.name: GetJsonInt_002
1147  * @tc.desc: return 232513
1148  * @tc.type: FUNC
1149  * @tc.require: AR000GHSJK
1150  */
1151 HWTEST_F(HichainConnectorTest, GetJsonInt_002, testing::ext::TestSize.Level0)
1152 {
1153     std::string key = "12";
1154     nlohmann::json jsonObj;
1155     jsonObj[key] = 232513;
1156     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1157     int32_t ret = hiChainConnector->GetJsonInt(jsonObj, key);
1158     EXPECT_EQ(ret, 232513);
1159 }
1160 
1161 /**
1162  * @tc.name: GetGroupIdExt_001
1163  * @tc.desc: return ERR_DM_FAILED
1164  * @tc.type: FUNC
1165  * @tc.require: AR000GHSJK
1166  */
1167 HWTEST_F(HichainConnectorTest, GetGroupIdExt_001, testing::ext::TestSize.Level0)
1168 {
1169     std::string userId = "12";
1170     int32_t groupType = 1;
1171     std::string groupId;
1172     std::string groupOwner;
1173     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1174     int32_t ret = hiChainConnector->GetGroupIdExt(userId, groupType, groupId, groupOwner);
1175     EXPECT_EQ(ret, ERR_DM_FAILED);
1176 }
1177 
1178 /**
1179  * @tc.name: ParseRemoteCredentialExt_001
1180  * @tc.desc: return ERR_DM_FAILED
1181  * @tc.type: FUNC
1182  * @tc.require: AR000GHSJK
1183  */
1184 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_001, testing::ext::TestSize.Level0)
1185 {
1186     std::string credentialInfo;
1187     std::string params;
1188     std::string groupOwner;
1189     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1190     int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1191     EXPECT_EQ(ret, ERR_DM_FAILED);
1192 }
1193 
1194 /**
1195  * @tc.name: ParseRemoteCredentialExt_002
1196  * @tc.desc: return ERR_DM_FAILED
1197  * @tc.type: FUNC
1198  * @tc.require: AR000GHSJK
1199  */
1200 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_002, testing::ext::TestSize.Level0)
1201 {
1202     nlohmann::json jsonObj;
1203     std::string credentialInfo = jsonObj.dump();
1204     std::string params;
1205     std::string groupOwner;
1206     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1207     int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1208     EXPECT_EQ(ret, ERR_DM_FAILED);
1209 }
1210 
1211 /**
1212  * @tc.name: ParseRemoteCredentialExt_003
1213  * @tc.desc: return ERR_DM_FAILED
1214  * @tc.type: FUNC
1215  * @tc.require: AR000GHSJK
1216  */
1217 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_003, testing::ext::TestSize.Level0)
1218 {
1219     nlohmann::json jsonObj;
1220     jsonObj["authType"] = 1;
1221     jsonObj[FIELD_USER_ID] = "156103";
1222     std::string credentialInfo = jsonObj.dump();
1223     std::string params;
1224     std::string groupOwner;
1225     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1226     int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1227     EXPECT_EQ(ret, ERR_DM_FAILED);
1228 }
1229 
1230 /**
1231  * @tc.name: ParseRemoteCredentialExt_004
1232  * @tc.desc: return ERR_DM_FAILED
1233  * @tc.type: FUNC
1234  * @tc.require: AR000GHSJK
1235  */
1236 HWTEST_F(HichainConnectorTest, ParseRemoteCredentialExt_004, testing::ext::TestSize.Level0)
1237 {
1238     nlohmann::json jsonObj;
1239     jsonObj["authType"] = 4;
1240     jsonObj[FIELD_USER_ID] = "156103";
1241     std::string credentialInfo = jsonObj.dump();
1242     std::string params;
1243     std::string groupOwner;
1244     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1245     int32_t ret = hiChainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
1246     EXPECT_EQ(ret, ERR_DM_FAILED);
1247 }
1248 
1249 /**
1250  * @tc.name: addMultiMembersExt_001
1251  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1252  * @tc.type: FUNC
1253  * @tc.require: AR000GHSJK
1254  */
1255 HWTEST_F(HichainConnectorTest, addMultiMembersExt_001, testing::ext::TestSize.Level0)
1256 {
1257     std::string credentialInfo;
1258     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1259     hiChainConnector->deviceGroupManager_ = nullptr;
1260     int32_t ret = hiChainConnector->addMultiMembersExt(credentialInfo);
1261     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1262 }
1263 
1264 /**
1265  * @tc.name: addMultiMembersExt_002
1266  * @tc.desc: return ERR_DM_FAILED
1267  * @tc.type: FUNC
1268  * @tc.require: AR000GHSJK
1269  */
1270 HWTEST_F(HichainConnectorTest, addMultiMembersExt_002, testing::ext::TestSize.Level0)
1271 {
1272     nlohmann::json jsonObj;
1273     std::string credentialInfo = jsonObj.dump();
1274     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1275     int32_t ret = hiChainConnector->addMultiMembersExt(credentialInfo);
1276     EXPECT_EQ(ret, ERR_DM_FAILED);
1277 }
1278 
1279 /**
1280  * @tc.name: GetTrustedDevices_001
1281  * @tc.desc: return true
1282  * @tc.type: FUNC
1283  * @tc.require: AR000GHSJK
1284  */
1285 HWTEST_F(HichainConnectorTest, GetTrustedDevices_001, testing::ext::TestSize.Level0)
1286 {
1287     std::string localDeviceUdid;
1288     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1289     auto ret = hiChainConnector->GetTrustedDevices(localDeviceUdid);
1290     EXPECT_EQ(ret.empty(), true);
1291 }
1292 
1293 /**
1294  * @tc.name: GetTrustedDevicesUdid_001
1295  * @tc.desc: return ERR_DM_FAILED
1296  * @tc.type: FUNC
1297  * @tc.require: AR000GHSJK
1298  */
1299 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_001, testing::ext::TestSize.Level0)
1300 {
1301     std::string jsonStr;
1302     std::vector<std::string> udidList;
1303     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1304     int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr.c_str(), udidList);
1305     EXPECT_EQ(ret, ERR_DM_FAILED);
1306 }
1307 
1308 /**
1309  * @tc.name: GetTrustedDevicesUdid_002
1310  * @tc.desc: return DM_OK
1311  * @tc.type: FUNC
1312  * @tc.require: AR000GHSJK
1313  */
1314 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_002, testing::ext::TestSize.Level0)
1315 {
1316     nlohmann::json jsonObj;
1317     std::string jsonStr = jsonObj.dump();
1318     std::vector<std::string> udidList;
1319     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1320     int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr.c_str(), udidList);
1321     EXPECT_EQ(ret, DM_OK);
1322 }
1323 
1324 /**
1325  * @tc.name: GetTrustedDevicesUdid_003
1326  * @tc.desc: Verify that the function returns DM_OK and correctly populates the udidList.
1327  * @tc.type: FUNC
1328  * @tc.require: AR000GHSJK
1329  */
1330 HWTEST_F(HichainConnectorTest, GetTrustedDevicesUdid_003, testing::ext::TestSize.Level0)
1331 {
1332     const char* jsonStr = R"({
1333         "device1": {
1334             "authId": "valid_udid_1"
1335         },
1336         "device2": {
1337             "authId": 12345
1338         },
1339         "device3": {
1340             "authId": "valid_udid_2"
1341         }
1342     })";
1343 
1344     std::vector<std::string> udidList;
1345     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1346     int32_t ret = hiChainConnector->GetTrustedDevicesUdid(jsonStr, udidList);
1347     EXPECT_EQ(ret, DM_OK);
1348 
1349     std::vector<std::string> expectedUdidList = {"valid_udid_1", "valid_udid_2"};
1350     EXPECT_EQ(udidList, expectedUdidList);
1351 }
1352 
1353 /**
1354  * @tc.name: DeleteAllGroup_001
1355  * @tc.type: FUNC
1356  * @tc.require: AR000GHSJK
1357  */
1358 HWTEST_F(HichainConnectorTest, DeleteAllGroup_001, testing::ext::TestSize.Level0)
1359 {
1360     int32_t userId = 1;
1361     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1362     hiChainConnector->DeleteAllGroup(userId);
1363     EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
1364 }
1365 
1366 /**
1367  * @tc.name: DeleteP2PGroup_001
1368  * @tc.type: FUNC
1369  * @tc.require: AR000GHSJK
1370  */
1371 HWTEST_F(HichainConnectorTest, DeleteP2PGroup_001, testing::ext::TestSize.Level0)
1372 {
1373     int32_t userId = 1;
1374     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1375     hiChainConnector->DeleteP2PGroup(userId);
1376     EXPECT_NE(hiChainConnector->deviceGroupManager_, nullptr);
1377 }
1378 
1379 /**
1380  * @tc.name: GetRelatedGroupsCommon_001
1381  * @tc.desc: return ERR_DM_FAILED
1382  * @tc.type: FUNC
1383  * @tc.require: AR000GHSJK
1384  */
1385 HWTEST_F(HichainConnectorTest, GetRelatedGroupsCommon_001, testing::ext::TestSize.Level0)
1386 {
1387     std::string deviceId;
1388     std::string  pkgName;
1389     std::vector<GroupInfo> groupList;
1390     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
1391     int32_t ret = hiChainConnector->GetRelatedGroupsCommon(deviceId, pkgName.c_str(), groupList);
1392     EXPECT_EQ(ret, ERR_DM_FAILED);
1393 }
1394 } // namespace
1395 } // namespace DistributedHardware
1396 } // namespace OHOS
1397