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_dm_pin_holder.h"
17#include "dm_device_info.h"
18
19#include <unistd.h>
20#include "accesstoken_kit.h"
21#include "device_manager_notify.h"
22#include "dm_constants.h"
23#include "dm_log.h"
24#include "ipc_authenticate_device_req.h"
25#include "ipc_get_info_by_network_req.h"
26#include "ipc_get_info_by_network_rsp.h"
27#include "ipc_get_local_device_info_rsp.h"
28#include "ipc_get_trustdevice_req.h"
29#include "ipc_get_trustdevice_rsp.h"
30#include "ipc_req.h"
31#include "ipc_rsp.h"
32#include "ipc_set_useroperation_req.h"
33#include "ipc_skeleton.h"
34#include "ipc_start_discovery_req.h"
35#include "ipc_stop_discovery_req.h"
36#include "ipc_publish_req.h"
37#include "ipc_unpublish_req.h"
38#include "ipc_unauthenticate_device_req.h"
39#include "nativetoken_kit.h"
40#include "nlohmann/json.hpp"
41#include "securec.h"
42#include "token_setproc.h"
43#include "pin_holder.h"
44#include "pinholder_session_callback.h"
45#include "softbus_error_code.h"
46
47namespace OHOS {
48namespace DistributedHardware {
49void DmPinHolderTest::SetUp()
50{
51    const int32_t permsNum = 2;
52    const int32_t indexZero = 0;
53    const int32_t indexOne = 1;
54    uint64_t tokenId;
55    const char *perms[permsNum];
56    perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
57    perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
58    NativeTokenInfoParams infoInstance = {
59        .dcapsNum = 0,
60        .permsNum = permsNum,
61        .aclsNum = 0,
62        .dcaps = NULL,
63        .perms = perms,
64        .acls = NULL,
65        .processName = "CollaborationFwk",
66        .aplStr = "system_core",
67    };
68    tokenId = GetAccessTokenId(&infoInstance);
69    SetSelfTokenID(tokenId);
70    OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
71}
72
73void DmPinHolderTest::TearDown()
74{
75}
76
77void DmPinHolderTest::SetUpTestCase()
78{
79}
80
81void DmPinHolderTest::TearDownTestCase()
82{
83}
84
85void DmPinHolderCallbackTest::OnCreateResult(int32_t result)
86{
87    std::cout << "OnCreateResult " << result << std::endl;
88}
89
90void DmPinHolderCallbackTest::OnDestroyResult(int32_t result)
91{
92    std::cout << "OnDestroyResult " << result << std::endl;
93}
94
95void DmPinHolderCallbackTest::OnPinHolderDestroy(DmPinType pinType, const std::string &payload)
96{
97    std::cout << "OnPinHolderDestroy" << std::endl;
98    std::cout << "pinType: " << pinType << std::endl;
99}
100
101void DmPinHolderCallbackTest::OnPinHolderCreate(const std::string &deviceId, DmPinType pinType,
102    const std::string &payload)
103{
104    std::cout << "OnPinHolderCreate" << std::endl;
105    std::cout << "pinType: " << pinType << std::endl;
106    std::cout << "payload: " << payload << std::endl;
107}
108
109void DmPinHolderCallbackTest::OnPinHolderEvent(DmPinHolderEvent event, int32_t result, const std::string &content)
110{
111    std::cout << "OnPinHolderEvent" << std::endl;
112    std::cout << "result: " << result << std::endl;
113    std::cout << "content: " << content << std::endl;
114}
115
116constexpr int32_t MSG_TYPE_CREATE_PIN_HOLDER = 600;
117constexpr int32_t MSG_TYPE_CREATE_PIN_HOLDER_RESP = 601;
118constexpr int32_t MSG_TYPE_DESTROY_PIN_HOLDER = 650;
119constexpr int32_t MSG_TYPE_DESTROY_PIN_HOLDER_RESP = 651;
120
121constexpr const char* TAG_PIN_TYPE = "PIN_TYPE";
122constexpr const char* TAG_PAYLOAD = "PAYLOAD";
123constexpr const char* TAG_REPLY = "REPLY";
124namespace {
125/**
126 * @tc.name: InitDeviceManager_001
127 * @tc.desc: 1. set packName not null
128 *              set dmInitCallback not null
129 *           2. call DeviceManagerImpl::InitDeviceManager with parameter
130 *           4. check ret is DM_OK
131 * deviceTypeId
132 * @tc.type: FUNC
133 * @tc.require: AR000GHSJK
134 */
135HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_101, testing::ext::TestSize.Level0)
136{
137    // 1. set packName not null
138    std::string packName = "com.ohos.dmtest";
139    // 2. set dmInitCallback not null
140    std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
141    int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
142
143    std::shared_ptr<DmPinHolderCallbackTest> pinHolderCallback = std::make_shared<DmPinHolderCallbackTest>();
144    ret = DeviceManager::GetInstance().RegisterPinHolderCallback(packName, pinHolderCallback);
145    // 3. check ret is DM_OK
146    ASSERT_EQ(ret, DM_OK);
147    DeviceManager::GetInstance().UnInitDeviceManager(packName);
148}
149
150HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_102, testing::ext::TestSize.Level0)
151{
152    std::string packName = "com.ohos.dmtest";
153    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
154    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
155    pinHolder->session_ = nullptr;
156    int32_t ret = pinHolder->RegisterPinHolderCallback(packName);
157    ASSERT_EQ(ret, ERR_DM_FAILED);
158}
159
160HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_103, testing::ext::TestSize.Level0)
161{
162    std::string packName = "com.ohos.dmtest";
163    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
164    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
165    pinHolder->session_ = std::make_shared<PinHolderSession>();
166    int32_t ret = pinHolder->RegisterPinHolderCallback(packName);
167    ASSERT_EQ(ret, DM_OK);
168}
169
170HWTEST_F(DmPinHolderTest, CreatePinholder_101, testing::ext::TestSize.Level0)
171{
172    std::string packName = "com.ohos.dmtest";
173    std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
174    int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
175
176    std::shared_ptr<DmPinHolderCallbackTest> pinHolderCallback = std::make_shared<DmPinHolderCallbackTest>();
177    ret = DeviceManager::GetInstance().RegisterPinHolderCallback(packName, pinHolderCallback);
178    PeerTargetId targetId;
179    DmPinType pinType = NUMBER_PIN_CODE;
180    std::string payload = "";
181    ret = DeviceManager::GetInstance().CreatePinHolder(packName, targetId, pinType, payload);
182    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
183    DeviceManager::GetInstance().UnInitDeviceManager(packName);
184}
185
186HWTEST_F(DmPinHolderTest, CreatePinholder_102, testing::ext::TestSize.Level0)
187{
188    std::string packName = "com.ohos.dmtest";
189    PeerTargetId targetId;
190    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
191    std::string payload;
192    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
193    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
194    pinHolder->registerPkgName_ = "";
195    int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload);
196    ASSERT_EQ(ret, ERR_DM_FAILED);
197}
198
199HWTEST_F(DmPinHolderTest, CreatePinholder_103, testing::ext::TestSize.Level0)
200{
201    std::string packName = "com.ohos.dmtest";
202    PeerTargetId targetId;
203    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
204    std::string payload;
205    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
206    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
207    pinHolder->registerPkgName_ = "dmtest";
208    int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload);
209    ASSERT_EQ(ret, ERR_DM_FAILED);
210}
211
212HWTEST_F(DmPinHolderTest, CreatePinholder_105, testing::ext::TestSize.Level0)
213{
214    std::string packName = "com.ohos.dmtest";
215    PeerTargetId targetId = {
216        .deviceId = "",
217        .brMac = "",
218        .bleMac = "",
219        .wifiIp = "",
220    };
221
222    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
223    std::string payload;
224    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
225    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
226    pinHolder->registerPkgName_ = packName;
227    int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload);
228    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
229}
230
231HWTEST_F(DmPinHolderTest, CreatePinholder_106, testing::ext::TestSize.Level0)
232{
233    std::string packName = "com.ohos.dmtest";
234    PeerTargetId targetId = {
235        .deviceId = "deviceId",
236        .brMac = "brMac",
237        .bleMac = "bleMac",
238        .wifiIp = "wifiIp",
239    };
240
241    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
242    std::string payload;
243    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
244    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
245    pinHolder->registerPkgName_ = packName;
246    pinHolder->listener_ = nullptr;
247    int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload);
248    ASSERT_EQ(ret, ERR_DM_FAILED);
249}
250
251HWTEST_F(DmPinHolderTest, CreatePinholder_107, testing::ext::TestSize.Level0)
252{
253    std::string packName = "com.ohos.dmtest";
254    PeerTargetId targetId = {
255        .deviceId = "deviceId",
256        .brMac = "brMac",
257        .bleMac = "bleMac",
258        .wifiIp = "wifiIp",
259    };
260
261    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
262    std::string payload;
263    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
264    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
265    pinHolder->registerPkgName_ = packName;
266    pinHolder->session_ = nullptr;
267    int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload);
268    ASSERT_EQ(ret, ERR_DM_FAILED);
269}
270
271HWTEST_F(DmPinHolderTest, CreatePinholder_108, testing::ext::TestSize.Level0)
272{
273    std::string packName = "com.ohos.dmtest";
274    PeerTargetId targetId = {
275        .deviceId = "deviceId",
276        .brMac = "brMac",
277        .bleMac = "bleMac",
278        .wifiIp = "wifiIp",
279    };
280
281    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
282    std::string payload;
283    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
284    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
285    pinHolder->registerPkgName_ = packName;
286    pinHolder->sourceState_ = SOURCE_CREATE;
287    int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload);
288    ASSERT_EQ(ret, ERR_DM_FAILED);
289}
290
291HWTEST_F(DmPinHolderTest, DestroyPinHolder_101, testing::ext::TestSize.Level0)
292{
293    std::string packName = "com.ohos.dmtest";
294    PeerTargetId targetId = {
295        .deviceId = "deviceId",
296        .brMac = "brMac",
297        .bleMac = "bleMac",
298        .wifiIp = "wifiIp",
299    };
300    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
301    std::string payload;
302    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
303    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
304    pinHolder->listener_ = nullptr;
305    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
306    ASSERT_EQ(ret, ERR_DM_FAILED);
307}
308
309HWTEST_F(DmPinHolderTest, DestroyPinHolder_102, testing::ext::TestSize.Level0)
310{
311    std::string packName = "com.ohos.dmtest";
312    PeerTargetId targetId = {
313        .deviceId = "deviceId",
314        .brMac = "brMac",
315        .bleMac = "bleMac",
316        .wifiIp = "wifiIp",
317    };
318    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
319    std::string payload;
320    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
321    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
322    pinHolder->session_ = nullptr;
323    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
324    ASSERT_EQ(ret, ERR_DM_FAILED);
325}
326
327HWTEST_F(DmPinHolderTest, DestroyPinHolder_103, testing::ext::TestSize.Level0)
328{
329    std::string packName = "com.ohos.dmtest";
330    PeerTargetId targetId = {
331        .deviceId = "deviceId",
332        .brMac = "brMac",
333        .bleMac = "bleMac",
334        .wifiIp = "wifiIp",
335    };
336    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
337    std::string payload;
338    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
339    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
340    pinHolder->registerPkgName_ = "";
341    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
342    ASSERT_EQ(ret, ERR_DM_FAILED);
343}
344
345HWTEST_F(DmPinHolderTest, DestroyPinHolder_104, testing::ext::TestSize.Level0)
346{
347    std::string packName = "com.ohos.dmtest";
348    PeerTargetId targetId = {
349        .deviceId = "deviceId",
350        .brMac = "brMac",
351        .bleMac = "bleMac",
352        .wifiIp = "wifiIp",
353    };
354    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
355    std::string payload;
356    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
357    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
358    pinHolder->registerPkgName_ = "dmtest";
359    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
360    ASSERT_EQ(ret, ERR_DM_FAILED);
361}
362
363HWTEST_F(DmPinHolderTest, DestroyPinHolder_105, testing::ext::TestSize.Level0)
364{
365    std::string packName = "com.ohos.dmtest";
366    PeerTargetId targetId = {
367        .deviceId = "",
368        .brMac = "",
369        .bleMac = "",
370        .wifiIp = "",
371    };
372    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
373    std::string payload;
374    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
375    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
376    pinHolder->registerPkgName_ = packName;
377    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
378    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
379}
380
381HWTEST_F(DmPinHolderTest, DestroyPinHolder_106, testing::ext::TestSize.Level0)
382{
383    std::string packName = "com.ohos.dmtest";
384    PeerTargetId targetId = {
385        .deviceId = "deviceId",
386        .brMac = "brMac",
387        .bleMac = "bleMac",
388        .wifiIp = "wifiIp",
389    };
390    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
391    std::string payload;
392    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
393    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
394    pinHolder->registerPkgName_ = packName;
395    pinHolder->sessionId_ = 0;
396    pinHolder->sourceState_ = SOURCE_DESTROY;
397    pinHolder->listener_ = std::make_shared<IDeviceManagerServiceListenerTest>();
398    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
399    ASSERT_EQ(ret, ERR_DM_FAILED);
400}
401
402HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_101, testing::ext::TestSize.Level0)
403{
404    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
405    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
406    pinHolder->listener_ = nullptr;
407    int32_t ret = pinHolder->CreateGeneratePinHolderMsg();
408    ASSERT_EQ(ret, ERR_DM_FAILED);
409}
410
411HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_102, testing::ext::TestSize.Level0)
412{
413    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
414    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
415    pinHolder->session_ = nullptr;
416    int32_t ret = pinHolder->CreateGeneratePinHolderMsg();
417    ASSERT_EQ(ret, ERR_DM_FAILED);
418}
419
420HWTEST_F(DmPinHolderTest, ParseMsgType_101, testing::ext::TestSize.Level0)
421{
422    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
423    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
424    std::string message;
425    int32_t ret = pinHolder->ParseMsgType(message);
426    ASSERT_EQ(ret, ERR_DM_FAILED);
427}
428
429HWTEST_F(DmPinHolderTest, ProcessCreateMsg_101, testing::ext::TestSize.Level0)
430{
431    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
432    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
433    std::string message;
434    pinHolder->listener_ = nullptr;
435    pinHolder->ProcessCreateMsg(message);
436    ASSERT_NE(pinHolder->timer_, nullptr);
437}
438
439HWTEST_F(DmPinHolderTest, ProcessCreateMsg_102, testing::ext::TestSize.Level0)
440{
441    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
442    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
443    std::string message;
444    pinHolder->session_ = nullptr;
445    pinHolder->ProcessCreateMsg(message);
446    ASSERT_NE(pinHolder->timer_, nullptr);
447}
448
449HWTEST_F(DmPinHolderTest, ProcessCreateMsg_103, testing::ext::TestSize.Level0)
450{
451    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
452    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
453    nlohmann::json jsonObject;
454    std::string message = jsonObject.dump();
455    pinHolder->ProcessCreateMsg(message);
456    ASSERT_NE(pinHolder->timer_, nullptr);
457}
458
459HWTEST_F(DmPinHolderTest, ProcessCreateMsg_104, testing::ext::TestSize.Level0)
460{
461    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
462    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
463    nlohmann::json jsonObject;
464    jsonObject[TAG_PIN_TYPE] = "TAG_PIN_TYPE";
465    std::string message = jsonObject.dump();
466    pinHolder->ProcessCreateMsg(message);
467    ASSERT_NE(pinHolder->timer_, nullptr);
468}
469
470HWTEST_F(DmPinHolderTest, ProcessCreateMsg_105, testing::ext::TestSize.Level0)
471{
472    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
473    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
474    nlohmann::json jsonObject;
475    jsonObject[TAG_PIN_TYPE] = DmPinType::SUPER_SONIC;
476    jsonObject[TAG_PAYLOAD] = DmPinType::SUPER_SONIC;
477    std::string message = jsonObject.dump();
478    pinHolder->ProcessCreateMsg(message);
479    ASSERT_NE(pinHolder->timer_, nullptr);
480}
481
482HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_101, testing::ext::TestSize.Level0)
483{
484    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
485    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
486    nlohmann::json jsonObject;
487    std::string message = jsonObject.dump();
488    pinHolder->ProcessCreateRespMsg(message);
489    ASSERT_NE(pinHolder->timer_, nullptr);
490}
491
492HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_102, testing::ext::TestSize.Level0)
493{
494    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
495    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
496    nlohmann::json jsonObject;
497    jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE;
498    std::string message = jsonObject.dump();
499    pinHolder->listener_ = nullptr;
500    pinHolder->ProcessCreateRespMsg(message);
501    ASSERT_NE(pinHolder->timer_, nullptr);
502}
503
504HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_103, testing::ext::TestSize.Level0)
505{
506    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
507    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
508    nlohmann::json jsonObject;
509    jsonObject[TAG_REPLY] = DmPinType::SUPER_SONIC;
510    std::string message = jsonObject.dump();
511    pinHolder->session_ = nullptr;
512    pinHolder->ProcessCreateRespMsg(message);
513    ASSERT_NE(pinHolder->timer_, nullptr);
514}
515
516HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_104, testing::ext::TestSize.Level0)
517{
518    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
519    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
520    nlohmann::json jsonObject;
521    jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE;
522    std::string message = jsonObject.dump();
523    pinHolder->session_ = nullptr;
524    pinHolder->ProcessCreateRespMsg(message);
525    ASSERT_NE(pinHolder->timer_, nullptr);
526}
527
528HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_101, testing::ext::TestSize.Level0)
529{
530    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
531    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
532    std::string message;
533    pinHolder->listener_ = nullptr;
534    pinHolder->ProcessDestroyMsg(message);
535    ASSERT_NE(pinHolder->timer_, nullptr);
536}
537
538HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_102, testing::ext::TestSize.Level0)
539{
540    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
541    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
542    std::string message;
543    pinHolder->session_ = nullptr;
544    pinHolder->ProcessDestroyMsg(message);
545    ASSERT_NE(pinHolder->timer_, nullptr);
546}
547
548HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_103, testing::ext::TestSize.Level0)
549{
550    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
551    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
552    nlohmann::json jsonObject;
553    std::string message = jsonObject.dump();
554    pinHolder->ProcessDestroyMsg(message);
555    ASSERT_NE(pinHolder->timer_, nullptr);
556}
557
558HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_104, testing::ext::TestSize.Level0)
559{
560    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
561    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
562    nlohmann::json jsonObject;
563    jsonObject[TAG_PIN_TYPE] = "TAG_PIN_TYPE";
564    std::string message = jsonObject.dump();
565    pinHolder->ProcessDestroyMsg(message);
566    ASSERT_NE(pinHolder->timer_, nullptr);
567}
568
569HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_105, testing::ext::TestSize.Level0)
570{
571    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
572    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
573    nlohmann::json jsonObject;
574    jsonObject[TAG_PIN_TYPE] = DmPinType::SUPER_SONIC;
575    jsonObject[TAG_PAYLOAD] = DmPinType::SUPER_SONIC;
576    std::string message = jsonObject.dump();
577    pinHolder->ProcessDestroyMsg(message);
578    ASSERT_NE(pinHolder->timer_, nullptr);
579}
580
581HWTEST_F(DmPinHolderTest, CloseSession_101, testing::ext::TestSize.Level0)
582{
583    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
584    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
585    std::string name;
586    pinHolder->session_ = nullptr;
587    pinHolder->CloseSession(name);
588    ASSERT_NE(pinHolder->timer_, nullptr);
589}
590
591HWTEST_F(DmPinHolderTest, OnDataReceived_101, testing::ext::TestSize.Level0)
592{
593    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
594    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
595    int32_t sessionId = 1;
596    nlohmann::json jsonObject;
597    jsonObject[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER;
598    std::string message = jsonObject.dump();
599    pinHolder->OnDataReceived(sessionId, message);
600    ASSERT_NE(pinHolder->timer_, nullptr);
601}
602
603HWTEST_F(DmPinHolderTest, OnDataReceived_102, testing::ext::TestSize.Level0)
604{
605    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
606    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
607    int32_t sessionId = 1;
608    nlohmann::json jsonObject;
609    jsonObject[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER_RESP;
610    std::string message = jsonObject.dump();
611    pinHolder->OnDataReceived(sessionId, message);
612    ASSERT_NE(pinHolder->timer_, nullptr);
613}
614
615HWTEST_F(DmPinHolderTest, OnDataReceived_103, testing::ext::TestSize.Level0)
616{
617    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
618    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
619    int32_t sessionId = 1;
620    nlohmann::json jsonObject;
621    jsonObject[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER;
622    std::string message = jsonObject.dump();
623    pinHolder->OnDataReceived(sessionId, message);
624    ASSERT_NE(pinHolder->timer_, nullptr);
625}
626
627HWTEST_F(DmPinHolderTest, OnDataReceived_104, testing::ext::TestSize.Level0)
628{
629    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
630    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
631    int32_t sessionId = 1;
632    nlohmann::json jsonObject;
633    jsonObject[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER_RESP;
634    std::string message = jsonObject.dump();
635    pinHolder->OnDataReceived(sessionId, message);
636    ASSERT_NE(pinHolder->timer_, nullptr);
637}
638
639HWTEST_F(DmPinHolderTest, OnDataReceived_105, testing::ext::TestSize.Level0)
640{
641    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
642    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
643    int32_t sessionId = 1;
644    int32_t data = 300;
645    nlohmann::json jsonObject;
646    jsonObject[TAG_MSG_TYPE] = data;
647    std::string message = jsonObject.dump();
648    pinHolder->OnDataReceived(sessionId, message);
649    ASSERT_NE(pinHolder->timer_, nullptr);
650}
651
652HWTEST_F(DmPinHolderTest, GetPeerDeviceId_101, testing::ext::TestSize.Level0)
653{
654    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
655    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
656    int32_t sessionId = 1;
657    std::string udidHash;
658    pinHolder->GetPeerDeviceId(sessionId, udidHash);
659    ASSERT_NE(pinHolder->timer_, nullptr);
660}
661
662HWTEST_F(DmPinHolderTest, OnSessionOpened_101, testing::ext::TestSize.Level0)
663{
664    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
665    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
666    int32_t sessionId = 1;
667    int32_t sessionSide = 0;
668    int32_t result = 0;
669    pinHolder->OnSessionOpened(sessionId, sessionSide, result);
670    ASSERT_NE(pinHolder->timer_, nullptr);
671}
672
673HWTEST_F(DmPinHolderTest, OnSessionOpened_102, testing::ext::TestSize.Level0)
674{
675    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
676    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
677    int32_t sessionId = 1;
678    int32_t sessionSide = 1;
679    int32_t result = 1;
680    pinHolder ->listener_ = nullptr;
681    pinHolder->OnSessionOpened(sessionId, sessionSide, result);
682    ASSERT_NE(pinHolder->timer_, nullptr);
683}
684
685
686HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_101, testing::ext::TestSize.Level0)
687{
688    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
689    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
690    PeerTargetId targetId = {
691        .deviceId = "",
692        .brMac = "",
693        .bleMac = "",
694        .wifiIp = "",
695    };
696    int32_t ret = pinHolder->CheckTargetIdVaild(targetId);
697    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
698}
699
700HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_102, testing::ext::TestSize.Level0)
701{
702    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
703    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
704    PeerTargetId targetId = {
705        .deviceId = "deviceId",
706        .brMac = "brMac",
707        .bleMac = "bleMac",
708        .wifiIp = "wifiIp",
709    };
710    int32_t ret = pinHolder->CheckTargetIdVaild(targetId);
711    ASSERT_EQ(ret, DM_OK);
712}
713
714HWTEST_F(DmPinHolderTest, NotifyPinHolderEvent_101, testing::ext::TestSize.Level0)
715{
716    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
717    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
718    std::string packName = "com.ohos.dmtest";
719    std::string event = "event";
720    int32_t ret = pinHolder->NotifyPinHolderEvent(packName, event);
721    ASSERT_EQ(ret, ERR_DM_FAILED);
722}
723
724HWTEST_F(DmPinHolderTest, OpenSessionServer_101, testing::ext::TestSize.Level0)
725{
726    std::shared_ptr<PinHolderSession> pinHolderSession = std::make_shared<PinHolderSession>();
727    PeerTargetId targetId = {
728        .deviceId = "deviceId",
729        .brMac = "brMac",
730        .bleMac = "bleMac",
731        .wifiIp = "wifiIp",
732    };
733    int32_t ret = pinHolderSession->OpenSessionServer(targetId);
734    EXPECT_NE(ret, -1);
735}
736
737HWTEST_F(DmPinHolderTest, CloseSessionServer_101, testing::ext::TestSize.Level0)
738{
739    std::shared_ptr<PinHolderSession> pinHolderSession = std::make_shared<PinHolderSession>();
740    int32_t sessionId = 1;
741    int32_t ret = pinHolderSession->CloseSessionServer(sessionId);
742    EXPECT_EQ(ret, DM_OK);
743}
744
745HWTEST_F(DmPinHolderTest, OnSessionOpened_103, testing::ext::TestSize.Level0)
746{
747    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
748    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
749    std::shared_ptr<PinHolderSession> pinHolderSession = std::make_shared<PinHolderSession>();
750    pinHolderSession->RegisterSessionCallback(pinHolder);
751    int sessionId = 1;
752    int result = 1;
753    int ret = pinHolderSession->OnSessionOpened(sessionId, result);
754    int closeSessionId = 2;
755    pinHolderSession->OnSessionClosed(closeSessionId);
756    EXPECT_EQ(ret, DM_OK);
757}
758
759HWTEST_F(DmPinHolderTest, SendData_101, testing::ext::TestSize.Level0)
760{
761    std::shared_ptr<PinHolderSession> pinHolderSession = std::make_shared<PinHolderSession>();
762    int32_t sessionId = 6;
763    std::string message = "123456";
764    int32_t ret = pinHolderSession->SendData(sessionId, message);
765    EXPECT_EQ(ret, ERR_DM_FAILED);
766}
767
768HWTEST_F(DmPinHolderTest, SendData_102, testing::ext::TestSize.Level0)
769{
770    std::shared_ptr<PinHolderSession> pinHolderSession = std::make_shared<PinHolderSession>();
771    int32_t sessionId = 6;
772    std::string message = R"(
773    {
774        "MSG_TYPE" : "789"
775    }
776    )";
777    int32_t ret = pinHolderSession->SendData(sessionId, message);
778    EXPECT_EQ(ret, ERR_DM_FAILED);
779}
780
781HWTEST_F(DmPinHolderTest, SendData_103, testing::ext::TestSize.Level0)
782{
783    std::shared_ptr<PinHolderSession> pinHolderSession = std::make_shared<PinHolderSession>();
784    int32_t sessionId = 6;
785    std::string message = R"(
786    {
787        "MSG_TYPE" : 100
788    }
789    )";
790    int32_t ret = pinHolderSession->SendData(sessionId, message);
791    EXPECT_NE(ret, DM_OK);
792}
793
794HWTEST_F(DmPinHolderTest, GetAddrByTargetId_101, testing::ext::TestSize.Level0)
795{
796    std::shared_ptr<PinHolderSession> pinHolderSession = std::make_shared<PinHolderSession>();
797    PeerTargetId targetId = {
798        .deviceId = "deviceIdTest",
799        .brMac = "brMacTest",
800        .bleMac = "bleMacTest",
801        .wifiIp = "wifiIpTest",
802        .wifiPort = 369,
803    };
804    ConnectionAddr addr;
805    int32_t ret = pinHolderSession->GetAddrByTargetId(targetId, addr);
806    EXPECT_EQ(ret, DM_OK);
807}
808} // namespace
809} // namespace DistributedHardware
810} // namespace OHOS