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_device_manager_impl.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_publish_req.h"
35 #include "ipc_unpublish_req.h"
36 #include "ipc_unauthenticate_device_req.h"
37 #include "nativetoken_kit.h"
38 #include "securec.h"
39 #include "token_setproc.h"
40 #include "softbus_error_code.h"
41
42 namespace OHOS {
43 namespace DistributedHardware {
44 constexpr int32_t DM_STRING_LENGTH_MAX = 1024;
SetUp()45 void DeviceManagerImplTest::SetUp()
46 {
47 const int32_t permsNum = 2;
48 const int32_t indexZero = 0;
49 const int32_t indexOne = 1;
50 uint64_t tokenId;
51 const char *perms[permsNum];
52 perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
53 perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
54 NativeTokenInfoParams infoInstance = {
55 .dcapsNum = 0,
56 .permsNum = permsNum,
57 .aclsNum = 0,
58 .dcaps = NULL,
59 .perms = perms,
60 .acls = NULL,
61 .processName = "dsoftbus_service",
62 .aplStr = "system_core",
63 };
64 tokenId = GetAccessTokenId(&infoInstance);
65 SetSelfTokenID(tokenId);
66 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
67 }
68
TearDown()69 void DeviceManagerImplTest::TearDown()
70 {
71 testing::Mock::VerifyAndClearExpectations(deviceManagerNotifyMock_.get());
72 testing::Mock::VerifyAndClearExpectations(ipcClientProxyMock_.get());
73 }
74
SetUpTestCase()75 void DeviceManagerImplTest::SetUpTestCase()
76 {
77 DmDeviceManagerNotify::dmDeviceManagerNotify = deviceManagerNotifyMock_;
78 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxyMock_;
79 }
80
TearDownTestCase()81 void DeviceManagerImplTest::TearDownTestCase()
82 {
83 DmDeviceManagerNotify::dmDeviceManagerNotify = nullptr;
84 deviceManagerNotifyMock_ = nullptr;
85 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
86 ipcClientProxyMock_ = nullptr;
87 }
88
89 namespace {
90 /**
91 * @tc.name: InitDeviceManager_001
92 * @tc.desc: 1. set packName not null
93 * set dmInitCallback not null
94 * 2. call DeviceManagerImpl::InitDeviceManager with parameter
95 * 4. check ret is DM_OK
96 * deviceTypeId
97 * @tc.type: FUNC
98 * @tc.require: AR000GHSJK
99 */
100 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_101, testing::ext::TestSize.Level0)
101 {
102 // 1. set packName not null
103 std::string packName = "com.ohos.test";
104 // set dmInitCallback not null
105 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
106 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
107 // 3. check ret is DM_OK
108 ASSERT_EQ(ret, DM_OK);
109 DeviceManager::GetInstance().UnInitDeviceManager(packName);
110 }
111
112 /**
113 * @tc.name: UnInitDeviceManager_101
114 * @tc.desc: 1. set packName not null
115 * 2. MOCK IpcClientProxy UnInit return DM_OK
116 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
117 * 4. check ret is DM_OK
118 * deviceTypeId
119 * @tc.type: FUNC
120 * @tc.require: AR000GHSJK
121 */
122 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_101, testing::ext::TestSize.Level0)
123 {
124 std::string packName = "com.ohos.test2";
125 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
126 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
127 ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
128 ASSERT_EQ(ret, DM_OK);
129 }
130
131 /**
132 * @tc.name: GetTrustedDeviceList_101
133 * @tc.desc: 1. set packName not null
134 * set extra null
135 * set deviceList null
136 * 2. MOCK IpcClientProxy SendRequest return DM_OK
137 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
138 * 4. check ret is DM_OK
139 * deviceTypeId
140 * @tc.type: FUNC
141 * @tc.require: AR000GHSJK
142 */
143 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_101, testing::ext::TestSize.Level0)
144 {
145 // 1. set packName not null
146 std::string packName = "com.ohos.test";
147 // set extra null
148 std::string extra = "";
149 // set deviceList null
150 std::vector<DmDeviceInfo> deviceList;
151 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
152 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
153 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
154 ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
155 // 3. check ret is DM_OK
156 ASSERT_EQ(ret, DM_OK);
157 DeviceManager::GetInstance().UnInitDeviceManager(packName);
158 }
159
160 /**
161 * @tc.name: GetAvailableDeviceList_101
162 * @tc.desc: 1. set packName null
163 * set deviceList null
164 * 2. call DeviceManagerImpl::GetAvailableDeviceList with parameter
165 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
166 * deviceTypeId
167 * @tc.type: FUNC
168 */
169 HWTEST_F(DeviceManagerImplTest, GetAvailableDeviceList_101, testing::ext::TestSize.Level0)
170 {
171 std::string packName;
172 std::vector<DmDeviceBasicInfo> deviceList;
173 int32_t ret = DeviceManager::GetInstance().GetAvailableDeviceList(packName, deviceList);
174 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
175 }
176
177 /**
178 * @tc.name: GetAvailableDeviceList_102
179 * @tc.desc: 1. set packName not null
180 * set deviceList null
181 * 2. InitDeviceManager return DM_OK
182 * 3. call DeviceManagerImpl::GetAvailableDeviceList with parameter
183 * 4. check ret is DM_OK
184 * deviceTypeId
185 * @tc.type: FUNC
186 */
187 HWTEST_F(DeviceManagerImplTest, GetAvailableDeviceList_102, testing::ext::TestSize.Level0)
188 {
189 std::string packName = "com.ohos.test";
190 std::vector<DmDeviceBasicInfo> deviceList;
191 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
192 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
193 ret = DeviceManager::GetInstance().GetAvailableDeviceList(packName, deviceList);
194 ASSERT_EQ(ret, DM_OK);
195 DeviceManager::GetInstance().UnInitDeviceManager(packName);
196 }
197
198 /**
199 * @tc.name: GetLocalDeviceNetWorkId_101
200 * @tc.desc: 1. set packName null
201 * set networkId null
202 * 2. call DeviceManagerImpl::GetLocalDeviceNetWorkId with parameter
203 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
204 * deviceTypeId
205 * @tc.type: FUNC
206 */
207 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceNetWorkId_101, testing::ext::TestSize.Level0)
208 {
209 std::string packName;
210 std::string networkId;
211 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
212 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
213 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceNetWorkId(packName, networkId);
214 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
215 }
216
217 /**
218 * @tc.name: GetLocalDeviceNetWorkId_102
219 * @tc.desc: 1. set packName not null
220 * set networkId not null
221 * 2. InitDeviceManager return DM_OK
222 * 3. call DeviceManagerImpl::GetLocalDeviceNetWorkId with parameter
223 * 4. check ret is DM_OK
224 * deviceTypeId
225 * @tc.type: FUNC
226 */
227 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceNetWorkId_102, testing::ext::TestSize.Level0)
228 {
229 std::string packName = "com.ohos.test";
230 std::string networkId = "networkId";
231 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
232 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
233 ret = DeviceManager::GetInstance().GetLocalDeviceNetWorkId(packName, networkId);
234 ASSERT_EQ(ret, DM_OK);
235 DeviceManager::GetInstance().UnInitDeviceManager(packName);
236 }
237
238 /**
239 * @tc.name: GetLocalDeviceId_101
240 * @tc.desc: 1. set packName null
241 * set deviceId null
242 * 2. call DeviceManagerImpl::GetLocalDeviceId with parameter
243 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
244 * deviceTypeId
245 * @tc.type: FUNC
246 */
247 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceId_101, testing::ext::TestSize.Level0)
248 {
249 std::string packName;
250 std::string deviceId;
251 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
252 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
253 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceId(packName, deviceId);
254 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
255 }
256
257 /**
258 * @tc.name: GetLocalDeviceId_102
259 * @tc.desc: 1. set packName not null
260 * set deviceId not null
261 * 2. InitDeviceManager return DM_OK
262 * 3. call DeviceManagerImpl::GetLocalDeviceId with parameter
263 * 4. check ret is DM_OK
264 * deviceTypeId
265 * @tc.type: FUNC
266 */
267 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceId_102, testing::ext::TestSize.Level0)
268 {
269 std::string packName = "com.ohos.test";
270 std::string deviceId = "deviceId";
271 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
272 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
273 ret = DeviceManager::GetInstance().GetLocalDeviceId(packName, deviceId);
274 ASSERT_EQ(ret, DM_OK);
275 DeviceManager::GetInstance().UnInitDeviceManager(packName);
276 }
277
278 /**
279 * @tc.name: GetLocalDeviceName_101
280 * @tc.desc: 1. set packName null
281 * set deviceName null
282 * 2. call DeviceManagerImpl::GetLocalDeviceName with parameter
283 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
284 * deviceTypeId
285 * @tc.type: FUNC
286 */
287 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_101, testing::ext::TestSize.Level0)
288 {
289 std::string packName;
290 std::string deviceName;
291 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
292 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
293 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceName(packName, deviceName);
294 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
295 }
296
297 /**
298 * @tc.name: GetLocalDeviceName_102
299 * @tc.desc: 1. set packName not null
300 * set deviceName not null
301 * 2. InitDeviceManager return DM_OK
302 * 3. call DeviceManagerImpl::GetLocalDeviceName with parameter
303 * 4. check ret is DM_OK
304 * deviceTypeId
305 * @tc.type: FUNC
306 */
307 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_102, testing::ext::TestSize.Level0)
308 {
309 std::string packName = "com.ohos.test";
310 std::string deviceName = "deviceName";
311 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
312 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
313 ret = DeviceManager::GetInstance().GetLocalDeviceName(packName, deviceName);
314 ASSERT_EQ(ret, DM_OK);
315 DeviceManager::GetInstance().UnInitDeviceManager(packName);
316 }
317
318
319 /**
320 * @tc.name: GetLocalDeviceType_101
321 * @tc.desc: 1. set packName null
322 * set deviceType 0
323 * 2. call DeviceManagerImpl::GetLocalDeviceType with parameter
324 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
325 * deviceTypeId
326 * @tc.type: FUNC
327 */
328 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceType_101, testing::ext::TestSize.Level0)
329 {
330 std::string packName;
331 int32_t deviceType = 0;
332 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
333 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
334 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceType(packName, deviceType);
335 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
336 }
337
338 /**
339 * @tc.name: GetLocalDeviceType_102
340 * @tc.desc: 1. set packName not null
341 * set deviceType 0
342 * 2. InitDeviceManager return DM_OK
343 * 3. call DeviceManagerImpl::GetLocalDeviceType with parameter
344 * 4. check ret is DM_OK
345 * deviceTypeId
346 * @tc.type: FUNC
347 */
348 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceType_102, testing::ext::TestSize.Level0)
349 {
350 std::string packName = "com.ohos.test";
351 int32_t deviceType = 0;
352 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
353 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
354 ret = DeviceManager::GetInstance().GetLocalDeviceType(packName, deviceType);
355 ASSERT_EQ(ret, DM_OK);
356 DeviceManager::GetInstance().UnInitDeviceManager(packName);
357 }
358
359 /**
360 * @tc.name: GetDeviceName_101
361 * @tc.desc: 1. set packName null
362 * set networkId not null
363 * set deviceName null
364 * 3. call DeviceManagerImpl::GetDeviceName with parameter
365 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
366 * deviceTypeId
367 * @tc.type: FUNC
368 */
369 HWTEST_F(DeviceManagerImplTest, GetDeviceName_101, testing::ext::TestSize.Level0)
370 {
371 std::string packName;
372 std::string networkId = "networkId";
373 std::string deviceName;
374 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
375 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
376 }
377
378 /**
379 * @tc.name: GetDeviceName_102
380 * @tc.desc: 1. set packName not null
381 * set networkId null
382 * set deviceName null
383 * 2. call DeviceManagerImpl::GetDeviceName with parameter
384 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
385 * deviceTypeId
386 * @tc.type: FUNC
387 */
388 HWTEST_F(DeviceManagerImplTest, GetDeviceName_102, testing::ext::TestSize.Level0)
389 {
390 std::string packName = "com.ohos.test";
391 std::string networkId;
392 std::string deviceName;
393 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
394 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
395 }
396
397 /**
398 * @tc.name: GetDeviceName_103
399 * @tc.desc: 1. set packName not null
400 * set networkId not null
401 * set deviceName null
402 * 2. call DeviceManagerImpl::GetDeviceName with parameter
403 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
404 * deviceTypeId
405 * @tc.type: FUNC
406 */
407 HWTEST_F(DeviceManagerImplTest, GetDeviceName_103, testing::ext::TestSize.Level0)
408 {
409 std::string packName = "com.ohos.test";
410 std::string networkId = "networkId";
411 std::string deviceName;
412 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
413 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
414 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
415 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
416 }
417
418 /**
419 * @tc.name: GetDeviceName_104
420 * @tc.desc: 1. set packName not null
421 * set networkId not null
422 * set deviceName null
423 * 2. InitDeviceManager return DM_OK
424 * 3. call DeviceManagerImpl::GetDeviceName with parameter
425 * 4. check ret is DM_OK
426 * deviceTypeId
427 * @tc.type: FUNC
428 */
429 HWTEST_F(DeviceManagerImplTest, GetDeviceName_104, testing::ext::TestSize.Level0)
430 {
431 std::string packName = "com.ohos.test";
432 std::string networkId = "networkId";
433 std::string deviceName;
434 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
435 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
436 ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
437 ASSERT_EQ(ret, DM_OK);
438 DeviceManager::GetInstance().UnInitDeviceManager(packName);
439 }
440
441 /**
442 * @tc.name: GetDeviceType_101
443 * @tc.desc: 1. set packName null
444 * set deviceList not null
445 * set deviceType 0
446 * 2. call DeviceManagerImpl::GetDeviceType with parameter
447 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
448 * deviceTypeId
449 * @tc.type: FUNC
450 */
451 HWTEST_F(DeviceManagerImplTest, GetDeviceType_101, testing::ext::TestSize.Level0)
452 {
453 std::string packName;
454 std::string networkId = "networkId";
455 int32_t deviceType = 0;
456 int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
457 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
458 }
459
460 /**
461 * @tc.name: GetDeviceType_102
462 * @tc.desc: 1. set packName not null
463 * set networkId null
464 * set deviceType 0
465 * 2. call DeviceManagerImpl::GetDeviceType with parameter
466 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
467 * deviceTypeId
468 * @tc.type: FUNC
469 */
470 HWTEST_F(DeviceManagerImplTest, GetDeviceType_102, testing::ext::TestSize.Level0)
471 {
472 std::string packName = "com.ohos.test";
473 std::string networkId;
474 int32_t deviceType = 0;
475 int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
476 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
477 }
478
479 /**
480 * @tc.name: GetDeviceType_103
481 * @tc.desc: 1. set packName not null
482 * set networkId not null
483 * set deviceType 0
484 * 2. call DeviceManagerImpl::GetDeviceType with parameter
485 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
486 * deviceTypeId
487 * @tc.type: FUNC
488 */
489 HWTEST_F(DeviceManagerImplTest, GetDeviceType_103, testing::ext::TestSize.Level0)
490 {
491 std::string packName = "com.ohos.test";
492 std::string networkId = "networkId";
493 int32_t deviceType = 0;
494 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
495 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
496 int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
497 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
498 }
499
500 /**
501 * @tc.name: GetDeviceType_104
502 * @tc.desc: 1. set packName not null
503 * set networkId not null
504 * set deviceType 0
505 * 2. InitDeviceManager return DM_OK
506 * 3. call DeviceManagerImpl::GetDeviceType with parameter
507 * 4. check ret is DM_OK
508 * deviceTypeId
509 * @tc.type: FUNC
510 */
511 HWTEST_F(DeviceManagerImplTest, GetDeviceType_104, testing::ext::TestSize.Level0)
512 {
513 std::string packName = "com.ohos.test";
514 std::string networkId = "networkId";
515 int32_t deviceType = 0;
516 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
517 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
518 ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
519 ASSERT_EQ(ret, DM_OK);
520 DeviceManager::GetInstance().UnInitDeviceManager(packName);
521 }
522
523 /**
524 * @tc.name: UnBindDevice_101
525 * @tc.desc: 1. set packName null
526 * set deviceId not null
527 * 2. call DeviceManagerImpl::UnBindDevice with parameter
528 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
529 * deviceTypeId
530 * @tc.type: FUNC
531 */
532 HWTEST_F(DeviceManagerImplTest, UnBindDevice_101, testing::ext::TestSize.Level0)
533 {
534 std::string packName ;
535 std::string deviceId = "deviceId";
536 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
537 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
538 }
539
540 /**
541 * @tc.name: UnBindDevice_102
542 * @tc.desc: 1. set packName not null
543 * set deviceId null
544 * 2. call DeviceManagerImpl::UnBindDevice with parameter
545 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
546 * deviceTypeId
547 * @tc.type: FUNC
548 */
549 HWTEST_F(DeviceManagerImplTest, UnBindDevice_102, testing::ext::TestSize.Level0)
550 {
551 std::string packName = "com.ohos.test";
552 std::string deviceId;
553 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
554 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
555 }
556
557 /**
558 * @tc.name: UnBindDevice_103
559 * @tc.desc: 1. set packName not null
560 * set deviceId not null
561 * 2. call DeviceManagerImpl::UnBindDevice with parameter
562 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
563 * deviceTypeId
564 * @tc.type: FUNC
565 */
566 HWTEST_F(DeviceManagerImplTest, UnBindDevice_103, testing::ext::TestSize.Level0)
567 {
568 std::string packName = "com.ohos.test";
569 std::string deviceId = "deviceId";
570 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
571 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
572 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
573 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
574 }
575
576 /**
577 * @tc.name: UnBindDevice_104
578 * @tc.desc: 1. set packName not null
579 * set deviceId not null
580 * 2. InitDeviceManager return DM_OK
581 * 3. call DeviceManagerImpl::UnBindDevice with parameter
582 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
583 * deviceTypeId
584 * @tc.type: FUNC
585 */
586 HWTEST_F(DeviceManagerImplTest, UnBindDevice_104, testing::ext::TestSize.Level0)
587 {
588 std::string packName;
589 std::string deviceId;
590 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
591 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
592 ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
593 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
594 DeviceManager::GetInstance().UnInitDeviceManager(packName);
595 }
596
597 HWTEST_F(DeviceManagerImplTest, UnBindDevice_105, testing::ext::TestSize.Level0)
598 {
599 std::string packName ;
600 std::string deviceId = "deviceId";
601 std::string extra = "extra";
602 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId, extra);
603 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
604 }
605
606 HWTEST_F(DeviceManagerImplTest, UnBindDevice_106, testing::ext::TestSize.Level0)
607 {
608 std::string packName = "com.ohos.test";
609 std::string deviceId;
610 std::string extra = "extra";
611 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId, extra);
612 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
613 }
614
615 /**
616 * @tc.name: BindDevice_101
617 * @tc.desc: 1. set packName null
618 * set bindType 0
619 * set deviceId not null
620 * set bindParam null
621 * set callback null
622 * 2. call DeviceManagerImpl::BindDevice with parameter
623 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
624 * deviceTypeId
625 * @tc.type: FUNC
626 */
627 HWTEST_F(DeviceManagerImplTest, BindDevice_101, testing::ext::TestSize.Level0)
628 {
629 std::string packName ;
630 int32_t bindType = 0;
631 std::string deviceId = "deviceId";
632 std::string bindParam;
633 std::shared_ptr<AuthenticateCallback> callback = nullptr;
634 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
635 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
636 }
637
638 /**
639 * @tc.name: BindDevice_102
640 * @tc.desc: 1. set packName not null
641 * set bindType 0
642 * set deviceId null
643 * set bindParam null
644 * set callback null
645 * 2. call DeviceManagerImpl::BindDevice with parameter
646 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
647 * deviceTypeId
648 * @tc.type: FUNC
649 */
650 HWTEST_F(DeviceManagerImplTest, BindDevice_102, testing::ext::TestSize.Level0)
651 {
652 std::string packName = "com.ohos.test";
653 int32_t bindType = 0;
654 std::string deviceId;
655 std::string bindParam;
656 std::shared_ptr<AuthenticateCallback> callback = nullptr;
657 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
658 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
659 }
660
661 /**
662 * @tc.name: BindDevice_103
663 * @tc.desc: 1. set packName not null
664 * set bindType 0
665 * set deviceId not null
666 * set bindParam null
667 * set callback null
668 * 2. call DeviceManagerImpl::BindDevice with parameter
669 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
670 * deviceTypeId
671 * @tc.type: FUNC
672 */
673 HWTEST_F(DeviceManagerImplTest, BindDevice_103, testing::ext::TestSize.Level0)
674 {
675 std::string packName = "com.ohos.test";
676 int32_t bindType = 0;
677 std::string deviceId = "deviceId";
678 std::string bindParam = "{\"status\":1}";
679 std::shared_ptr<AuthenticateCallback> callback = nullptr;
680 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
681 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
682 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
683 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
684 }
685
686 /**
687 * @tc.name: BindDevice_104
688 * @tc.desc: 1. set packName not null
689 * set bindType 0
690 * set deviceId not null
691 * set bindParam null
692 * set callback null
693 * 2. InitDeviceManager return DM_OK
694 * 3. call DeviceManagerImpl::BindDevice with parameter
695 * 4. check ret is not DM_OK
696 * deviceTypeId
697 * @tc.type: FUNC
698 */
699 HWTEST_F(DeviceManagerImplTest, BindDevice_104, testing::ext::TestSize.Level0)
700 {
701 std::string packName = "com.ohos.test";
702 int32_t bindType = 0;
703 std::string deviceId = "deviceId";
704 std::string bindParam;
705 std::shared_ptr<AuthenticateCallback> callback = nullptr;
706 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
707 DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
708 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
709 ASSERT_NE(ret, DM_OK);
710 DeviceManager::GetInstance().UnInitDeviceManager(packName);
711 }
712
713 /**
714 * @tc.name: RegisterDevStateCallback_101
715 * @tc.desc: 1. set packName not null
716 * set extra not null
717 * set callback not null
718 * 2. InitDeviceManager return DM_OK
719 * 3. call DeviceManagerImpl::RegisterDevStateCallback with parameter
720 * 4. check ret is DM_OK
721 * deviceTypeId
722 * @tc.type: FUNC
723 */
724 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_101, testing::ext::TestSize.Level0)
725 {
726 std::string packName = "com.ohos.test";
727 std::string extra = "extra";
728 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>();
729 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
730 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
731 ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
732 bool res = (ret == ERR_DM_NO_PERMISSION) || (ret == DM_OK);
733 ASSERT_EQ(res, true);
734 DeviceManager::GetInstance().UnInitDeviceManager(packName);
735 }
736
737 /**
738 * @tc.name: RegisterDevStateCallback_102
739 * @tc.desc: 1. set packName null
740 * set extra not null
741 * set callback not null
742 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
743 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
744 * deviceTypeId
745 * @tc.type: FUNC
746 */
747 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_102, testing::ext::TestSize.Level0)
748 {
749 std::string packName;
750 std::string extra = "extra";
751 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>();
752 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
753 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
754 }
755
756 /**
757 * @tc.name: RegisterDevStateCallback_103
758 * @tc.desc: 1. set packName null
759 * set extra not null
760 * set callback not null
761 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
762 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
763 * deviceTypeId
764 * @tc.type: FUNC
765 */
766 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_103, testing::ext::TestSize.Level0)
767 {
768 std::string packName = "com.ohos.test";
769 std::string extra = "extra";
770 std::shared_ptr<DeviceStateCallback> callback = nullptr;
771 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
772 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
773 }
774
775 /**
776 * @tc.name: UnRegisterDevStateCallback_101
777 * @tc.desc: 1. set packName not null
778 * 2. InitDeviceManager return DM_OK
779 * 3. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
780 * 4. check ret is DM_OK
781 * deviceTypeId
782 * @tc.type: FUNC
783 */
784 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallbackk_101, testing::ext::TestSize.Level0)
785 {
786 std::string packName = "com.ohos.test";
787 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
788 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
789 ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
790 ASSERT_EQ(ret, DM_OK);
791 DeviceManager::GetInstance().UnInitDeviceManager(packName);
792 }
793
794 /**
795 * @tc.name: UnRegisterDevStateCallback_102
796 * @tc.desc: 1. set packName null
797 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
798 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
799 * deviceTypeId
800 * @tc.type: FUNC
801 */
802 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_102, testing::ext::TestSize.Level0)
803 {
804 std::string packName;
805 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
806 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
807 }
808
809 /**
810 * @tc.name: GetLocalDeviceInfo_101
811 * @tc.desc: 1. set packName null
812 * set extra null
813 * set deviceList null
814 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
815 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
816 * deviceTypeId
817 * @tc.type: FUNC
818 * @tc.require: AR000GHSJK
819 */
820 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_101, testing::ext::TestSize.Level0)
821 {
822 // 1. set packName not null
823 std::string packName = "com.ohos.test";
824 // set extra null
825 DmDeviceInfo info;
826 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
827 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
828 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
829 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
830 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
831 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
832 ASSERT_EQ(ret, DM_OK);
833 DeviceManager::GetInstance().UnInitDeviceManager(packName);
834 }
835
836 /**
837 * @tc.name: StartDeviceDiscovery_101
838 * @tc.desc: 1. set packName not null
839 * set subscribeInfo null
840 * set callback not null
841 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
842 * 3. check ret is DM_OK
843 * deviceTypeId
844 * @tc.type: FUNC
845 * @tc.require: AR000GHSJK
846 */
847 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_101, testing::ext::TestSize.Level0)
848 {
849 std::string packName = "com.ohos.helloworld";
850 std::string extra = "";
851 DmSubscribeInfo subscribeInfo;
852 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
853 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
854 ASSERT_EQ(ret, DM_OK);
855 DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId);
856 }
857
858 /**
859 * @tc.name: StartDeviceDiscovery_102
860 * @tc.desc: 1. set packName not null
861 * set subscribeInfo null
862 * set callback not null
863 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
864 * 3. check ret is DM_OK
865 * deviceTypeId
866 * @tc.type: FUNC
867 * @tc.require: AR000GHSJK
868 */
869 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_102, testing::ext::TestSize.Level0)
870 {
871 std::string packName = "com.ohos.helloworld";
872 std::string extra = "{\"findDeviceMode\":1}";
873 DmSubscribeInfo subscribeInfo;
874 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
875 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
876 ASSERT_EQ(ret, DM_OK);
877 ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId);
878 }
879
880 /**
881 * @tc.name: StartDeviceDiscovery_103
882 * @tc.desc: 1. set packName not null
883 * set subscribeId 0
884 * set filterOptions null
885 * set callback not null
886 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
887 * 3. check ret is DM_OK
888 * deviceTypeId
889 * @tc.type: FUNC
890 * @tc.require: AR000GHSJK
891 */
892 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_103, testing::ext::TestSize.Level0)
893 {
894 std::string packName = "com.ohos.helloworld";
895 uint16_t subscribeId = 0;
896 std::string filterOptions;
897 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
898 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
899 ASSERT_EQ(ret, DM_OK);
900 DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
901 }
902
903 /**
904 * @tc.name: StartDeviceDiscovery_104
905 * @tc.desc: 1. set packName not null
906 * set subscribeId 0
907 * set filterOptions null
908 * set callback not null
909 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
910 * 3. check ret is ERR_DM_DISCOVERY_REPEATED
911 * deviceTypeId
912 * @tc.type: FUNC
913 * @tc.require: AR000GHSJK
914 */
915 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_104, testing::ext::TestSize.Level0)
916 {
917 std::string packName = "com.ohos.helloworld";
918 uint16_t subscribeId = 0;
919 std::string filterOptions;
920 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
921 DmDeviceInfo deviceInfo;
922 callback->OnDeviceFound(subscribeId, deviceInfo);
923 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
924 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
925 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
926 ASSERT_NE(ret, DM_OK);
927 }
928
929 /**
930 * @tc.name: StopDeviceDiscovery_101
931 * @tc.desc: 1. set packName not null
932 * set subscribeInfo null
933 * set callback not null
934 * 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
935 * 3. check ret is DM_OK
936 * deviceTypeId
937 * @tc.type: FUNC
938 * @tc.require: AR000GHSJK
939 */
940 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_101, testing::ext::TestSize.Level0)
941 {
942 std::string packName = "com.ohos.test";
943 std::string extra = "";
944 DmSubscribeInfo subscribeInfo;
945 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
946 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId);
947 ASSERT_NE(ret, DM_OK);
948 }
949
950 /**
951 * @tc.name: StopDeviceDiscovery_102
952 * @tc.desc: 1. set packName not null
953 * set subscribeId is 0
954 * 2. InitDeviceManager return DM_OK
955 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
956 * 4. check ret is DM_OK
957 * deviceTypeId
958 * @tc.type: FUNC
959 * @tc.require: AR000GHSJK
960 */
961 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_102, testing::ext::TestSize.Level0)
962 {
963 // 1. set packName not null
964 std::string packName = "com.ohos.test";
965 // set subscribeInfo is 0
966 uint16_t subscribeId = 0;
967 // 2. InitDeviceManager return DM_OK
968 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
969 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
970 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
971 ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
972 // 4. check ret is DM_OK
973 ASSERT_NE(ret, ERR_DM_TIME_OUT);
974 DeviceManager::GetInstance().UnInitDeviceManager(packName);
975 }
976
977 /**
978 * @tc.name: PublishDeviceDiscovery_101
979 * @tc.desc: 1. set packName not null
980 * set publishInfo null
981 * set callback not null
982 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
983 * 3. check ret is DM_OK
984 * deviceTypeId
985 * @tc.type: FUNC
986 * @tc.require: I5N1K3
987 */
988 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_101, testing::ext::TestSize.Level0)
989 {
990 std::string packName = "com.ohos.helloworld";
991 DmPublishInfo publishInfo;
992 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
993 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
994 ASSERT_EQ(ret, DM_OK);
995 }
996
997 /**
998 * @tc.name: UnPublishDeviceDiscovery_101
999 * @tc.desc: 1. set packName not null
1000 * set publishId is 0
1001 * 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1002 * 3. check ret is DM_OK
1003 * deviceTypeId
1004 * @tc.type: FUNC
1005 * @tc.require: I5N1K3
1006 */
1007 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_101, testing::ext::TestSize.Level0)
1008 {
1009 std::string packName = "com.ohos.test";
1010 int32_t publishId = 0;
1011 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1012 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
1013 ASSERT_EQ(ret, DM_OK);
1014 }
1015
1016 /**
1017 * @tc.name: AuthenticateDevice_101
1018 * @tc.desc: 1. set packName not null
1019 * set dmDeviceInfo null
1020 * set dmAppImageInfo null
1021 * set extra null
1022 * set callback null
1023 * 2. InitDeviceManager return DM_OK
1024 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1025 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
1026 * deviceTypeId
1027 * @tc.type: FUNC
1028 * @tc.require: AR000GHSJK
1029 */
1030 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_101, testing::ext::TestSize.Level0)
1031 {
1032 // 1. set packName not null
1033 std::string packName = "com.ohos.helloworld";
1034 // set dmDeviceInfo null
1035 int32_t authType = 1;
1036 // set dmAppImageInfo null
1037 DmDeviceInfo dmDeviceInfo;
1038 strcpy_s(dmDeviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, "123XXXX");
1039 strcpy_s(dmDeviceInfo.deviceName, DM_MAX_DEVICE_NAME_LEN, "234");
1040 dmDeviceInfo.deviceTypeId = 0;
1041 // set extra null
1042 std::string extra = "test";
1043 // set callback null
1044 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1045 // 2.InitDeviceManager return DM_OK
1046 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
1047 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
1048 ASSERT_EQ(ret, DM_OK);
1049 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1050 ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
1051 // 4. check ret is DM_OK
1052 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1053 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1054 }
1055
1056 /**
1057 * @tc.name: UnAuthenticateDevice_101
1058 * @tc.desc: 1. set packName not null
1059 * set dmDeviceInfo null
1060 * set dmAppImageInfo null
1061 * set extra null
1062 * set callback null
1063 * 2. InitDeviceManager return DM_OK
1064 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1065 * 4. check ret is DM_OK
1066 * deviceTypeId
1067 * @tc.type: FUNC
1068 * @tc.require: AR000GHSJK
1069 */
1070 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_101, testing::ext::TestSize.Level0)
1071 {
1072 // 1. set packName not null
1073 std::string packName = "com.ohos.helloworld";
1074 DmDeviceInfo deviceInfo;
1075 deviceInfo.networkId[0] = '1';
1076 deviceInfo.networkId[1] = '2';
1077 deviceInfo.networkId[2] = '\0';
1078 // set callback null
1079 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1080 // 2. InitDeviceManager return DM_OK
1081 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
1082 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
1083 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1084 ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
1085 // 4. check ret is ERR_DM_FAILED
1086 ASSERT_NE(ret, ERR_DM_TIME_OUT);
1087 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1088 }
1089
1090 /**
1091 * @tc.name: SetUserOperation_101
1092 * @tc.desc: 1. set packName not null
1093 * set action null
1094 * 2. InitDeviceManager return DM_OK
1095 * 3. call DeviceManagerImpl::SetUserOperation with parameter
1096 * 4. check ret is DM_OK
1097 * deviceTypeId
1098 * @tc.type: FUNC
1099 * @tc.require: AR000GHSJK
1100 */
1101 HWTEST_F(DeviceManagerImplTest, SetUserOperation_101, testing::ext::TestSize.Level0)
1102 {
1103 // 1. set packName not null
1104 std::string packName = "com.ohos.test";
1105 // set authParam null
1106 int32_t action = 0;
1107 const std::string param = "extra";
1108 // 2. InitDeviceManager return DM_OK
1109 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1110 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1111 // 3. call DeviceManagerImpl::SetUserOperation with parameter
1112 ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
1113 // 4. check ret is DM_OK
1114 ASSERT_EQ(ret, DM_OK);
1115 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1116 }
1117
1118 /**
1119 * @tc.name: InitDeviceManager_001
1120 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt
1121 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
1122 * deviceTypeId
1123 * @tc.type: FUNC
1124 * @tc.require: AR000GHSJK
1125 */
1126 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_001, testing::ext::TestSize.Level0)
1127 {
1128 // 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt
1129 std::string packName = "";
1130 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr;
1131 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, dmInitCallback);
1132 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1133 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1134 }
1135
1136 /**
1137 * @tc.name: InitDeviceManager_002
1138 * @tc.desc: 1. set packName not null
1139 * set dmInitCallback not null
1140 * 2. call DeviceManagerImpl::InitDeviceManager with parameter
1141 * 3. check ret is DM_OK
1142 * deviceTypeId
1143 * @tc.type: FUNC
1144 * @tc.require: AR000GHSJK
1145 */
1146 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_002, testing::ext::TestSize.Level0)
1147 {
1148 // 1. set packName not null
1149 std::string packName = "com.ohos.test";
1150 // set dmInitCallback not null
1151 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1152 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1153 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1154 // 3. check ret is DM_OK
1155 ASSERT_EQ(ret, DM_OK);
1156 }
1157
1158 /**
1159 * @tc.name: InitDeviceManager_003
1160 * @tc.desc: 1. set packName not null
1161 * set dmInitCallback not null
1162 * 2. MOCK IpcClientProxy Init return ERR_DM_INIT_FAILED
1163 * 3. call DeviceManagerImpl::InitDeviceManager with parameter
1164 * 4. check ret is ERR_DM_INIT_FAILED
1165 * deviceTypeId
1166 * @tc.type: FUNC
1167 * @tc.require: AR000GHSJK
1168 */
1169 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_003, testing::ext::TestSize.Level0)
1170 {
1171 // 1. set packName not null
1172 std::string packName = "com.ohos.test";
1173 // set dmInitCallback not null
1174 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1175 // 2. MOCK IpcClientProxy Init return ERR_DM_FAILED
1176 // 3. call DeviceManagerImpl::InitDeviceManager with parameter
1177 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1178 // 4. check ret is DM_OK
1179 ASSERT_EQ(ret, DM_OK);
1180 }
1181
1182 /**
1183 * @tc.name: InitDeviceManager_004
1184 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1185 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
1186 * deviceTypeId
1187 * @tc.type: FUNC
1188 * @tc.require: AR000GHSJK
1189 */
1190 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_004, testing::ext::TestSize.Level0)
1191 {
1192 // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1193 std::string packName = "com.ohos.test";
1194 std::shared_ptr<DmInitCallbackTest> callback = nullptr;
1195 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1196 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1197 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1198 }
1199
1200 /**
1201 * @tc.name: InitDeviceManager_005
1202 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1203 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
1204 * deviceTypeId
1205 * @tc.type: FUNC
1206 * @tc.require: AR000GHSJK
1207 */
1208 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_005, testing::ext::TestSize.Level0)
1209 {
1210 // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1211 std::string packName = "";
1212 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1213 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1214 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1215 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1216 }
1217
1218 /**
1219 * @tc.name: UnInitDeviceManager_001
1220 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1221 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
1222 * deviceTypeId
1223 * @tc.type: FUNC
1224 * @tc.require: AR000GHSJK
1225 */
1226 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_001, testing::ext::TestSize.Level0)
1227 {
1228 // 1. set packName not null
1229 std::string packName = "";
1230 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1231 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1232 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1233 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1234 }
1235
1236 /**
1237 * @tc.name: UnInitDeviceManager_002
1238 * @tc.desc: 1. set packName not null
1239 * 2. MOCK IpcClientProxy UnInit return ERR_DM_FAILED
1240 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1241 * 4. check ret is ERR_DM_FAILED
1242 * deviceTypeId
1243 * @tc.type: FUNC
1244 * @tc.require: AR000GHSJK
1245 */
1246 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_002, testing::ext::TestSize.Level0)
1247 {
1248 // 1. set packName not null
1249 std::string packName = "com.ohos.test";
1250 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1251 EXPECT_CALL(*ipcClientProxyMock_, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1252 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1253 // 3. check ret is ERR_DM_FAILED
1254 ASSERT_EQ(ret, ERR_DM_FAILED);
1255 }
1256
1257 /**
1258 * @tc.name: UnInitDeviceManager_003
1259 * @tc.desc: 1. set packName not null
1260 * 2. MOCK IpcClientProxy UnInit return DM_OK
1261 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1262 * 4. check ret is DM_OK
1263 * deviceTypeId
1264 * @tc.type: FUNC
1265 * @tc.require: AR000GHSJK
1266 */
1267 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_003, testing::ext::TestSize.Level0)
1268 {
1269 // 1. set packName not null
1270 std::string packName = "com.ohos.test";
1271 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1272 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1273 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1274 ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1275 // 3. check ret is DM_OK
1276 ASSERT_EQ(ret, DM_OK);
1277 }
1278
1279 /**
1280 * @tc.name: UnInitDeviceManager_004
1281 * @tc.desc: 1. set packName not null
1282 * 2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED
1283 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1284 * 4. check ret is ERR_DM_FAILED
1285 * deviceTypeId
1286 * @tc.type: FUNC
1287 * @tc.require: AR000GHSJK
1288 */
1289 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_004, testing::ext::TestSize.Level0)
1290 {
1291 // 1. set packNamen not null
1292 std::string packName = "com.ohos.test";
1293 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1294 EXPECT_CALL(*ipcClientProxyMock_, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1295 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1296 // 3. check ret is ERR_DM_FAILED
1297 ASSERT_EQ(ret, ERR_DM_FAILED);
1298 }
1299
1300 /**
1301 * @tc.name: UnInitDeviceManager_005
1302 * @tc.desc: 1. set packName not null
1303 * 2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED
1304 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1305 * 4. check ret is ERR_DM_FAILED
1306 * deviceTypeId
1307 * @tc.type: FUNC
1308 * @tc.require: AR000GHSJK
1309 */
1310 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_005, testing::ext::TestSize.Level0)
1311 {
1312 // 1. set packName not null
1313 std::string packName = "com.ohos.test";
1314 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1315 EXPECT_CALL(*ipcClientProxyMock_, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1316 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1317 // 3. check ret is ERR_DM_FAILED
1318 ASSERT_EQ(ret, ERR_DM_FAILED);
1319 }
1320
1321 /**
1322 * @tc.name: GetTrustedDeviceList_001
1323 * @tc.desc: 1. set packName null
1324 * set extra null
1325 * set deviceList null
1326 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1327 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1328 * deviceTypeId
1329 * @tc.type: FUNC
1330 * @tc.require: AR000GHSJK
1331 */
1332 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0)
1333 {
1334 // 1. set packName null
1335 std::string packName = "";
1336 // set extra null
1337 std::string extra = "";
1338 // set deviceList null
1339 std::vector<DmDeviceInfo> deviceList;
1340 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1341 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1342 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1343 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1344 }
1345
1346 /**
1347 * @tc.name: GetTrustedDeviceList_002
1348 * @tc.desc: 1. set packName not null
1349 * set extra null
1350 * set deviceList null
1351 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1352 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1353 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1354 * deviceTypeId
1355 * @tc.type: FUNC
1356 * @tc.require: AR000GHSJK
1357 */
1358 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0)
1359 {
1360 // 1. set packName not null
1361 std::string packName = "com.ohos.test";
1362 // set extra null
1363 std::string extra = "";
1364 // set deviceList null
1365 std::vector<DmDeviceInfo> deviceList;
1366 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1367 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1368 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1369 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1370 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1371 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1372 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1373 }
1374
1375 /**
1376 * @tc.name: GetTrustedDeviceList_003
1377 * @tc.desc: 1. set packName not null
1378 * set extra null
1379 * set deviceList null
1380 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1381 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1382 * 4. check ret is DM_OK
1383 * deviceTypeId
1384 * @tc.type: FUNC
1385 * @tc.require: AR000GHSJK
1386 */
1387 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_003, testing::ext::TestSize.Level0)
1388 {
1389 // 1. set packName not null
1390 std::string packName = "com.ohos.test";
1391 // set extra null
1392 std::string extra = "";
1393 // set deviceList null
1394 std::vector<DmDeviceInfo> deviceList;
1395 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1396 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1397 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1398 // 3. check ret is DM_OK
1399 ASSERT_EQ(ret, DM_OK);
1400 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1401 }
1402
1403 /**
1404 * @tc.name: GetTrustedDeviceList_004
1405 * @tc.desc: 1. set packName not null
1406 * set extra null
1407 * set deviceList null
1408 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1409 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1410 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1411 * deviceTypeId
1412 * @tc.type: FUNC
1413 * @tc.require: AR000GHSJK
1414 */
1415 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_004, testing::ext::TestSize.Level0)
1416 {
1417 // 1. set packName not null
1418 std::string packName = "com.ohos.test";
1419 // set extra null
1420 std::string extra = "test";
1421 // set deviceList null
1422 std::vector<DmDeviceInfo> deviceList;
1423 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1424 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1425 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1426 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1427 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1428 // 3. check ret is DEVICEMANAGER_IPC_FAILED
1429 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1430 }
1431
1432 /**
1433 * @tc.name: GetTrustedDeviceList_005
1434 * @tc.desc: 1. set packName null
1435 * set extra null
1436 * set deviceList null
1437 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1438 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1439 * deviceTypeId
1440 * @tc.type: FUNC
1441 * @tc.require: AR000GHSJK
1442 */
1443 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_005, testing::ext::TestSize.Level0)
1444 {
1445 // 1. set packName null
1446 std::string packName = "";
1447 // set extra null
1448 std::string extra = "test";
1449 // set deviceList null
1450 std::vector<DmDeviceInfo> deviceList;
1451 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1452 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1453 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1454 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1455 }
1456
1457 /**
1458 * @tc.name: GetTrustedDeviceList_006
1459 * @tc.desc: 1. set packName null
1460 * set extra null
1461 * set deviceList null
1462 * set isRefresh true
1463 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1464 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1465 * deviceTypeId
1466 * @tc.type: FUNC
1467 */
1468 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_006, testing::ext::TestSize.Level0)
1469 {
1470 std::string packName = "";
1471 std::string extra = "";
1472 bool isRefresh = true;
1473 std::vector<DmDeviceInfo> deviceList;
1474 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, isRefresh, deviceList);
1475 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1476 }
1477
1478 /**
1479 * @tc.name: GetTrustedDeviceList_007
1480 * @tc.desc: 1. set packName not null
1481 * set extra null
1482 * set deviceList null
1483 * set isRefresh true
1484 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1485 * 3. check ret is DM_OK
1486 * deviceTypeId
1487 * @tc.type: FUNC
1488 */
1489 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_007, testing::ext::TestSize.Level0)
1490 {
1491 std::string packName = "com.ohos.test";
1492 std::string extra = "";
1493 bool isRefresh = true;
1494 std::vector<DmDeviceInfo> deviceList;
1495 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, isRefresh, deviceList);
1496 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1497 }
1498
1499 /**
1500 * @tc.name: GetTrustedDeviceList_008
1501 * @tc.desc: 1. set packName not null
1502 * set extra null
1503 * set deviceList null
1504 * set isRefresh true
1505 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1506 * 3. check ret is DM_OK
1507 * deviceTypeId
1508 * @tc.type: FUNC
1509 */
1510 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_008, testing::ext::TestSize.Level0)
1511 {
1512 std::string packName = "";
1513 std::map<std::string, std::string> filterOptions;
1514 bool isRefresh = false;
1515 std::vector<DmDeviceInfo> deviceList;
1516 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, filterOptions, isRefresh, deviceList);
1517 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1518 packName = "packNameTest";
1519 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1520 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1521 ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, filterOptions, isRefresh, deviceList);
1522 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1523 }
1524
1525 /**
1526 * @tc.name: ImportCredential_001
1527 * @tc.desc: 1. set pkgName not null
1528 * set reqJsonStr null
1529 * set returnJsonStr null
1530 * 2. call DeviceManagerImpl::ImportCredential with parameter
1531 * 3. check ret is DM_OK
1532 * deviceTypeId
1533 * @tc.type: FUNC
1534 */
1535 HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
1536 {
1537 std::string pkgName = "";
1538 std::string reqJsonStr = "";
1539 std::string returnJsonStr = "";
1540 int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1541 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1542 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1543 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1544 pkgName = "pkgNameTest";
1545 ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1546 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1547 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1548 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1549 pkgName = "";
1550 reqJsonStr = "reqJsonStrTest";
1551 ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1552 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1553 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1554 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1555 pkgName = "pkgNameTest";
1556 ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1557 ASSERT_NE(ret, ERR_DM_TIME_OUT);
1558 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1559 .Times(3).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED))
1560 .WillOnce(testing::Return(DM_OK)).WillOnce(testing::Return(DM_OK));
1561 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1562 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1563 ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1564 ASSERT_EQ(ret, DM_OK);
1565 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1566 ASSERT_EQ(ret, DM_OK);
1567 }
1568
1569 /**
1570 * @tc.name: RequestCredential_001
1571 * @tc.desc: 1. set pkgName not null
1572 * set reqJsonStr null
1573 * set returnJsonStr null
1574 * 2. call DeviceManagerImpl::RequestCredential with parameter
1575 * 3. check ret is DM_OK
1576 * deviceTypeId
1577 * @tc.type: FUNC
1578 */
1579 HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
1580 {
1581 std::string pkgName = "";
1582 std::string reqJsonStr = "";
1583 std::string returnJsonStr = "";
1584 int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
1585 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1586 ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1587 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1588 pkgName = "pkgNameTest";
1589 ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
1590 ASSERT_EQ(ret, DM_OK);
1591 ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1592 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1593 pkgName = "";
1594 reqJsonStr = "reqJsonStrTest";
1595 ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
1596 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1597 ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1598 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1599 pkgName = "pkgNameTest";
1600 ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
1601 ASSERT_EQ(ret, DM_OK);
1602 ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1603 ASSERT_EQ(ret, DM_OK);
1604 }
1605
1606 /**
1607 * @tc.name: GenerateEncryptedUuid_001
1608 * @tc.desc: 1. set packName null
1609 * set extra null
1610 * set deviceList null
1611 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1612 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1613 * deviceTypeId
1614 * @tc.type: FUNC
1615 */
1616 HWTEST_F(DeviceManagerImplTest, GenerateEncryptedUuid_001, testing::ext::TestSize.Level0)
1617 {
1618 std::string pkgName = "";
1619 std::string uuid = "";
1620 std::string appId = "";
1621 std::string encryptedUuid = "";
1622 int32_t ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1623 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1624 pkgName = "pkgNameTest";
1625 ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1626 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1627 pkgName = "";
1628 uuid = "uuidTest";
1629 ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1630 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1631 pkgName = "pkgNameTest";
1632 ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1633 ASSERT_EQ(ret, DM_OK);
1634 ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1635 ASSERT_EQ(ret, DM_OK);
1636 }
1637
1638 /**
1639 * @tc.name: GetNetworkTypeByNetworkId_001
1640 * @tc.desc: 1. set pkgName null
1641 * set networkId null
1642 * set networkType null
1643 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1644 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1645 * deviceTypeId
1646 * @tc.type: FUNC
1647 */
1648 HWTEST_F(DeviceManagerImplTest, GetNetworkTypeByNetworkId_001, testing::ext::TestSize.Level0)
1649 {
1650 std::string pkgName = "";
1651 std::string networkId = "";
1652 int32_t netWorkType = 0;
1653 int32_t ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1654 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1655 pkgName = "pkgNameTest";
1656 ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1657 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1658 pkgName = "";
1659 networkId = "networkIdTest";
1660 ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1661 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1662 pkgName = "pkgNameTest";
1663 ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1664 ASSERT_EQ(ret, DM_OK);
1665 ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1666 ASSERT_EQ(ret, DM_OK);
1667 }
1668
1669 /**
1670 * @tc.name: ImportAuthCode_001
1671 * @tc.desc: 1. set packName null
1672 * set authCode null
1673 * 2. call DeviceManagerImpl::ImportAuthCode with parameter
1674 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1675 * deviceTypeId
1676 * @tc.type: FUNC
1677 */
1678 HWTEST_F(DeviceManagerImplTest, ImportAuthCode_001, testing::ext::TestSize.Level0)
1679 {
1680 std::string pkgName = "";
1681 std::string authCode = "";
1682 int32_t ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1683 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1684 pkgName = "pkgNameTest";
1685 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1686 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1687 pkgName = "";
1688 authCode = "authCodeTest";
1689 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1690 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1691 pkgName = "pkgNameTest";
1692 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1693 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1694 authCode = "authoCo";
1695 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1696 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1697 }
1698
1699 /**
1700 * @tc.name: RegisterDiscoveryCallback_001
1701 * @tc.desc: 1. set packName null
1702 * set discoverParam null
1703 * set filterOptions null
1704 * set callback null
1705 * 2. call DeviceManagerImpl::RegisterDiscoveryCallback with parameter
1706 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1707 * deviceTypeId
1708 * @tc.type: FUNC
1709 */
1710 HWTEST_F(DeviceManagerImplTest, RegisterDiscoveryCallback_001, testing::ext::TestSize.Level0)
1711 {
1712 std::string pkgName = "";
1713 std::map<std::string, std::string> discoverParam;
1714 std::map<std::string, std::string> filterOptions;
1715 std::shared_ptr<DiscoveryCallback> callback = nullptr;
1716 int32_t ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName,
1717 discoverParam, filterOptions, callback);
1718 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1719 ret = DeviceManager::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions, callback);
1720 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1721 ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName);
1722 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1723 ret = DeviceManager::GetInstance().StopDiscovering(pkgName, discoverParam);
1724 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1725 pkgName = "pkgNameTest";
1726 ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName, discoverParam, filterOptions, callback);
1727 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1728 ret = DeviceManager::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions, callback);
1729 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1730 callback = std::make_shared<DeviceDiscoveryCallbackTest>();
1731 ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName);
1732 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1733 ret = DeviceManager::GetInstance().StopDiscovering(pkgName, discoverParam);
1734 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1735 }
1736
1737 /**
1738 * @tc.name: StartAdvertising_001
1739 * @tc.desc: 1. set packName null
1740 * set discoverParam null
1741 * set filterOptions null
1742 * set callback null
1743 * 2. call DeviceManagerImpl::StartAdvertising with parameter
1744 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1745 * deviceTypeId
1746 * @tc.type: FUNC
1747 */
1748 HWTEST_F(DeviceManagerImplTest, StartAdvertising_001, testing::ext::TestSize.Level0)
1749 {
1750 std::string pkgName = "";
1751 std::map<std::string, std::string> advertiseParam;
1752 std::shared_ptr<PublishCallback> callback = nullptr;
1753 int32_t ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
1754 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1755 ret = DeviceManager::GetInstance().StopDiscovering(pkgName, advertiseParam);
1756 pkgName = "pkgNameTest";
1757 ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
1758 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1759 ret = DeviceManager::GetInstance().StopDiscovering(pkgName, advertiseParam);
1760 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1761 callback = std::make_shared<DevicePublishCallbackTest>();
1762 ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
1763 ASSERT_EQ(ret, DM_OK);
1764 }
1765
1766 /**
1767 * @tc.name: BindTarget_001
1768 * @tc.desc: 1. set packName null
1769 * set targetId null
1770 * set unbindParam null
1771 * set callback null
1772 * 2. call DeviceManagerImpl::BindTarget with parameter
1773 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1774 * deviceTypeId
1775 * @tc.type: FUNC
1776 */
1777 HWTEST_F(DeviceManagerImplTest, BindTarget_001, testing::ext::TestSize.Level0)
1778 {
1779 std::string pkgName = "";
1780 PeerTargetId targetId;
1781 std::map<std::string, std::string> unbindParam;
1782 std::shared_ptr<BindTargetCallback> callback = nullptr;
1783 std::shared_ptr<UnbindTargetCallback> uncallback = nullptr;
1784 int32_t ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
1785 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1786 ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
1787 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1788 targetId.deviceId = "deviceIdTest";
1789 targetId.brMac = "brMacTest";
1790 targetId.bleMac = "bleMacTest";
1791 targetId.wifiIp = "wifiIpTest";
1792 ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
1793 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1794 ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
1795 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1796 pkgName = "pkgNameTest";
1797 ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
1798 ASSERT_EQ(ret, DM_OK);
1799 ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
1800 ASSERT_EQ(ret, DM_OK);
1801 }
1802
1803 /**
1804 * @tc.name: GetLocalDeviceInfo_001
1805 * @tc.desc: 1. set packName null
1806 * set extra null
1807 * set deviceList null
1808 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1809 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1810 * deviceTypeId
1811 * @tc.type: FUNC
1812 * @tc.require: AR000GHSJK
1813 */
1814 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0)
1815 {
1816 // 1. set packName not null
1817 std::string packName = "com.ohos.test";
1818 DmDeviceInfo info;
1819 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1820 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1821 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1822 ASSERT_EQ(ret, DM_OK);
1823 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1824 }
1825
1826 /**
1827 * @tc.name: GetLocalDeviceInfo_002
1828 * @tc.desc: 1. set packName not null
1829 * set extra null
1830 * set deviceList null
1831 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1832 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1833 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1834 * deviceTypeId
1835 * @tc.type: FUNC
1836 * @tc.require: AR000GHSJK
1837 */
1838 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_002, testing::ext::TestSize.Level0)
1839 {
1840 // 1. set packName not null
1841 std::string packName = "com.ohos.test";
1842 // set extra null
1843 DmDeviceInfo info;
1844 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1845 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1846 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1847 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1848 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1849 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1850 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1851 }
1852
1853 /**
1854 * @tc.name: GetLocalDeviceInfo_003
1855 * @tc.desc: 1. set packName not null
1856 * set extra null
1857 * set deviceList null
1858 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1859 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1860 * 4. check ret is DM_OK
1861 * deviceTypeId
1862 * @tc.type: FUNC
1863 * @tc.require: AR000GHSJK
1864 */
1865 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_003, testing::ext::TestSize.Level0)
1866 {
1867 // 1. set packName not null
1868 std::string packName = "com.ohos.test";
1869 // set extra null
1870 DmDeviceInfo info;
1871 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1872 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1873 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1874 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1875 // 3. check ret is DM_OK
1876 ASSERT_EQ(ret, DM_OK);
1877 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1878 }
1879
1880 /**
1881 * @tc.name: GetLocalDeviceInfo_004
1882 * @tc.desc: 1. set packName not null
1883 * set extra null
1884 * set deviceList null
1885 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1886 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1887 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1888 * deviceTypeId
1889 * @tc.type: FUNC
1890 * @tc.require: AR000GHSJK
1891 */
1892 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_004, testing::ext::TestSize.Level0)
1893 {
1894 // 1. set packName not null
1895 std::string packName = "com.ohos.test";
1896 // set extra null
1897 DmDeviceInfo info;
1898 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1899 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1900 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1901 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1902 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1903 // 3. check ret is DEVICEMANAGER_IPC_FAILED
1904 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1905 }
1906
1907 /**
1908 * @tc.name: GetLocalDeviceInfo_005
1909 * @tc.desc: 1. set packName null
1910 * set extra null
1911 * set deviceList null
1912 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1913 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1914 * deviceTypeId
1915 * @tc.type: FUNC
1916 * @tc.require: AR000GHSJK
1917 */
1918 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_005, testing::ext::TestSize.Level0)
1919 {
1920 // 1. set packName not null
1921 std::string packName = "";
1922 // set extra null
1923 DmDeviceInfo info;
1924 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1925 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1926 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1927 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1928 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1929 // 3. check ret is DEVICEMANAGER_IPC_FAILED
1930 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1931 }
1932
1933 /**
1934 * @tc.name: RegisterDevStateCallback_001
1935 * @tc.desc: 1. set packName null
1936 * set extra null
1937 * set callback null
1938 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1939 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
1940 * deviceTypeId
1941 * @tc.type: FUNC
1942 * @tc.require: AR000GHSJK
1943 */
1944 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0)
1945 {
1946 // 1. set packName null
1947 std::string packName = "";
1948 // set extra null
1949 std::string extra = "";
1950 // set callback nullptr
1951 std::shared_ptr<DeviceStateCallback> callback = nullptr;
1952 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1953 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
1954 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1955 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1956 }
1957
1958 /**
1959 * @tc.name: RegisterDevStateCallback_002
1960 * @tc.desc: 1. set packName not null
1961 * set extra null
1962 * set callback not null
1963 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1964 * 3. check ret is DM_OK
1965 * deviceTypeId
1966 * @tc.type: FUNC
1967 * @tc.require: AR000GHSJK
1968 */
1969 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_002, testing::ext::TestSize.Level0)
1970 {
1971 // 1. set packName null
1972 std::string packName = "com.ohos.test";
1973 // set extra null
1974 std::string extra = "";
1975 // set callback not null
1976 std::shared_ptr<DeviceStateCallback> dsCallback =std::make_shared<DeviceStateCallbackTest>();
1977 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1978 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1979 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1980 ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, dsCallback);
1981 // 3. check ret is DM_OK
1982 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1983 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1984 }
1985
1986 /**
1987 * @tc.name: RegisterDevStateCallback_003
1988 * @tc.desc: 1. set packName null
1989 * set extra not null
1990 * set callback null
1991 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1992 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1993 * deviceTypeId
1994 * @tc.type: FUNC
1995 * @tc.require: AR000GHSJK
1996 */
1997 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_003, testing::ext::TestSize.Level0)
1998 {
1999 // 1. set packName null
2000 std::string pkgName = "";
2001 // set extra null
2002 std::string extra = "test";
2003 // set callback nullptr
2004 std::shared_ptr<DeviceStateCallback> callback = nullptr;
2005 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2006 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
2007 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2008 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2009 }
2010
2011 /**
2012 * @tc.name: RegisterDevStateCallback_004
2013 * @tc.desc: 1. set packName not null
2014 * set extra not null
2015 * set callback not null
2016 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2017 * 3. check ret is DM_OK
2018 * deviceTypeId
2019 * @tc.type: FUNC
2020 * @tc.require: AR000GHSJK
2021 */
2022 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_004, testing::ext::TestSize.Level0)
2023 {
2024 // 1. set packName null
2025 std::string pkgName = "com.ohos.test";
2026 // set extra null
2027 std::string extra = "test";
2028 // set callback nullptr
2029 std::shared_ptr<DeviceStateCallback> callback = nullptr;
2030 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2031 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
2032 // 3. check ret is DM_OK
2033 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2034 }
2035
2036 /**
2037 * @tc.name: RegisterDevStateCallback_005
2038 * @tc.desc: 1. set packName not null
2039 * set extra not null
2040 * set callback null
2041 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2042 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2043 * deviceTypeId
2044 * @tc.type: FUNC
2045 * @tc.require: AR000GHSJK
2046 */
2047 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_005, testing::ext::TestSize.Level0)
2048 {
2049 // 1. set packName null
2050 std::string pkgName = "com.ohos.test";
2051 // set extra null
2052 std::string extra = "test1";
2053 // set callback nullptr
2054 std::shared_ptr<DeviceStateCallback> callback = nullptr;
2055 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2056 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
2057 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2058 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2059 }
2060
2061 /**
2062 * @tc.name: RegisterDevStateCallback_006
2063 * @tc.desc: 1. set packName not null
2064 * set extra not null
2065 * set callback null
2066 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2067 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2068 * deviceTypeId
2069 * @tc.type: FUNC
2070 * @tc.require: AR000GHSJK
2071 */
2072 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_006, testing::ext::TestSize.Level0)
2073 {
2074 std::string pkgName = "";
2075 std::map<std::string, std::string> extraParam;
2076 std::shared_ptr<DeviceStateCallback> callback = nullptr;
2077 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
2078 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2079 pkgName = "pkgNameTest";
2080 ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
2081 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2082 callback = std::make_shared<DeviceStateCallbackTest>();
2083 ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
2084 ASSERT_EQ(ret, DM_OK);
2085 pkgName = "";
2086 ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
2087 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2088 }
2089
2090 /**
2091 * @tc.name: UnRegisterDevStateCallback_001
2092 * @tc.desc: 1. set packName null
2093 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2094 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2095 * deviceTypeId
2096 * @tc.type: FUNC
2097 * @tc.require: AR000GHSJK
2098 */
2099 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0)
2100 {
2101 // 1. set packName null
2102 std::string packName = "";
2103 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2104 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2105 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2106 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2107 }
2108
2109 /**
2110 * @tc.name: UnRegisterDevStateCallback_002
2111 * @tc.desc: 1. set packName null
2112 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2113 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2114 * deviceTypeId
2115 * @tc.type: FUNC
2116 * @tc.require: AR000GHSJK
2117 */
2118 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_002, testing::ext::TestSize.Level0)
2119 {
2120 // 1. set packName null
2121 std::string packName = "";
2122 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2123 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2124 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2125 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2126 }
2127
2128 /**
2129 * @tc.name: UnRegisterDevStateCallback_003
2130 * @tc.desc: 1. set packName null
2131 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2132 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2133 * deviceTypeId
2134 * @tc.type: FUNC
2135 * @tc.require: AR000GHSJK
2136 */
2137 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_003, testing::ext::TestSize.Level0)
2138 {
2139 // 1. set packName null
2140 std::string packName = "";
2141 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2142 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2143 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2144 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2145 }
2146
2147 /**
2148 * @tc.name: UnRegisterDevStateCallback_004
2149 * @tc.desc: 1. set packName null
2150 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2151 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2152 * deviceTypeId
2153 * @tc.type: FUNC
2154 * @tc.require: AR000GHSJK
2155 */
2156 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_004, testing::ext::TestSize.Level0)
2157 {
2158 // 1. set packName null
2159 std::string packName = "";
2160 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2161 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2162 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2163 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2164 }
2165
2166 /**
2167 * @tc.name: UnRegisterDevStateCallback_005
2168 * @tc.desc: 1. set packName null
2169 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2170 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2171 * deviceTypeId
2172 * @tc.type: FUNC
2173 * @tc.require: AR000GHSJK
2174 */
2175 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_005, testing::ext::TestSize.Level0)
2176 {
2177 // 1. set packName null
2178 std::string packName = "";
2179 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2180 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2181 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2182 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2183 }
2184
2185 /**
2186 * @tc.name: StartDeviceDiscovery_001
2187 * @tc.desc: 1. set packName null
2188 * set subscribeInfo null
2189 * set callback null
2190 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2191 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2192 * deviceTypeId
2193 * @tc.type: FUNC
2194 * @tc.require: AR000GHSJK
2195 */
2196 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
2197 {
2198 // 1. set packName null
2199 std::string packName = "";
2200 // set subscribeInfo null
2201 std::string extra = "test";
2202 DmSubscribeInfo subscribeInfo;
2203 // set callback null
2204 std::shared_ptr<DiscoveryCallback> callback = nullptr;
2205 // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2206 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2207 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2208 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2209 }
2210
2211 /**
2212 * @tc.name: StartDeviceDiscovery_002
2213 * @tc.desc: 1. set packName null
2214 * set subscribeInfo null
2215 * set callback null
2216 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2217 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2218 * deviceTypeId
2219 * @tc.type: FUNC
2220 * @tc.require: AR000GHSJK
2221 */
2222 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
2223 {
2224 // 1. set packName null
2225 std::string packName = "com.ohos.helloworld";
2226 std::string extra = "test";
2227 // set subscribeInfo null
2228 DmSubscribeInfo subscribeInfo;
2229 // set callback null
2230 std::shared_ptr<DiscoveryCallback> callback = nullptr;
2231 // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2232 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2233 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2234 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2235 }
2236
2237 /**
2238 * @tc.name: StartDeviceDiscovery_003
2239 * @tc.desc: 1. set packName null
2240 * set subscribeInfo null
2241 * set callback null
2242 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2243 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
2244 * deviceTypeId
2245 * @tc.type: FUNC
2246 * @tc.require: AR000GHSJK
2247 */
2248 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0)
2249 {
2250 // 1. set packName not null
2251 std::string packName = "com.ohos.test";
2252 // set subscribeInfo is 0
2253 DmSubscribeInfo subscribeInfo;
2254 std::string extra = "test";
2255 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
2256 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2257 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2258 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2259 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2260 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2261 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2262 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2263 }
2264
2265 /**
2266 * @tc.name: StartDeviceDiscovery_004
2267 * @tc.desc: 1. set packName not null
2268 * set subscribeInfo null
2269 * set callback not null
2270 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2271 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2272 * 4. check ret is DM_OK
2273 * deviceTypeId
2274 * @tc.type: FUNC
2275 * @tc.require: AR000GHSJK
2276 */
2277 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0)
2278 {
2279 // 1. set packName not null
2280 std::string packName = "com.ohos.helloworld";
2281 std::string extra = "test";
2282 // set subscribeInfo null
2283 DmSubscribeInfo subscribeInfo;
2284 // set callback not null
2285 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
2286 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2287 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2288 .Times(1).WillOnce(testing::Return(DM_OK));
2289 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2290 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2291 // 4. check ret is DM_OK
2292 ASSERT_EQ(ret, DM_OK);
2293 }
2294
2295 /**
2296 * @tc.name: StartDeviceDiscovery_005
2297 * @tc.desc: 1. set packName not null
2298 * set subscribeInfo null
2299 * set callback not null
2300 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2301 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2302 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2303 * deviceTypeId
2304 * @tc.type: FUNC
2305 * @tc.require: AR000GHSJK
2306 */
2307 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_005, testing::ext::TestSize.Level0)
2308 {
2309 // 1. set packName not null
2310 std::string packName = "com.ohos.helloworld";
2311 std::string extra = "test";
2312 // set subscribeInfo null
2313 DmSubscribeInfo subscribeInfo;
2314 // set callback not null
2315 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
2316 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2317 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2318 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2319 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2320 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2321 // 4. check ret is DEVICEMANAGER_IPC_FAILED
2322 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2323 }
2324
2325 /**
2326 * @tc.name: IsSameAccount_001
2327 * @tc.desc: 1. set udid or bundleName null
2328 * 2. call DeviceManagerImpl::IsSameAccount with parameter
2329 * 3. check ret is false
2330 * @tc.type: FUNC
2331 */
2332 HWTEST_F(DeviceManagerImplTest, IsSameAccount_001, testing::ext::TestSize.Level0)
2333 {
2334 std::string udid = "";
2335 bool ret = DeviceManager::GetInstance().IsSameAccount(udid);
2336 ASSERT_EQ(ret, false);
2337 }
2338
2339 /**
2340 * @tc.name: IsSameAccount_002
2341 * @tc.desc: 1. set udid and bundleName not null
2342 * 2. call DeviceManagerImpl::IsSameAccount with parameter
2343 * 3. check ret is true
2344 * @tc.type: FUNC
2345 */
2346 HWTEST_F(DeviceManagerImplTest, IsSameAccount_002, testing::ext::TestSize.Level0)
2347 {
2348 std::string udid = "udidTest";
2349 std::string pkgName = "com.ohos.sameaccounttest";
2350 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
2351 DeviceManager::GetInstance().InitDeviceManager(pkgName, initCallback);
2352 bool ret = DeviceManager::GetInstance().IsSameAccount(udid);
2353 ASSERT_EQ(ret, true);
2354 }
2355
2356 /**
2357 * @tc.name: AddPublishCallback_001
2358 * @tc.desc: 1. set udid and bundleName not null
2359 * 2. call DeviceManagerImpl::AddPublishCallback with parameter
2360 * 3. check ret is true
2361 * @tc.type: FUNC
2362 */
2363 HWTEST_F(DeviceManagerImplTest, AddPublishcCllback_001, testing::ext::TestSize.Level0)
2364 {
2365 std::string pkgName = "com.ohos.test";
2366 int32_t ret = DeviceManagerImpl::GetInstance().AddPublishCallback(pkgName);
2367 ASSERT_NE(ret, 0);
2368 ret = DeviceManagerImpl::GetInstance().RemovePublishCallback(pkgName);
2369 ASSERT_NE(ret, 0);
2370 }
2371
2372 /**
2373 * @tc.name: RegisterPinHolderCallback_001
2374 * @tc.desc: 1. set udid and bundleName not null
2375 * 2. call DeviceManagerImpl::RegisterPinHolderCallback with parameter
2376 * 3. check ret is true
2377 * @tc.type: FUNC
2378 */
2379 HWTEST_F(DeviceManagerImplTest, RegisterPinHolderCallback_001, testing::ext::TestSize.Level0)
2380 {
2381 std::string pkgName = "";
2382 std::shared_ptr<PinHolderCallback> callback = nullptr;
2383 int32_t ret = DeviceManager::GetInstance().RegisterPinHolderCallback(pkgName, callback);
2384 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2385 pkgName = "pkgNameTest";
2386 ret = DeviceManager::GetInstance().RegisterPinHolderCallback(pkgName, callback);
2387 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2388 }
2389
2390 /**
2391 * @tc.name: CreatePinHolder_001
2392 * @tc.desc: 1. set udid and bundleName not null
2393 * 2. call DeviceManagerImpl::CreatePinHolder with parameter
2394 * 3. check ret is true
2395 * @tc.type: FUNC
2396 */
2397 HWTEST_F(DeviceManagerImplTest, CreatePinHolder_001, testing::ext::TestSize.Level0)
2398 {
2399 std::string pkgName = "";
2400 PeerTargetId targetId;
2401 DmPinType pinType = DmPinType::QR_CODE;
2402 std::string payload = "payload";
2403 int32_t ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2404 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2405 pkgName = "com.ohos.test";
2406 targetId.deviceId = "deviceIdTest";
2407 targetId.brMac = "brMacTest";
2408 targetId.bleMac = "bleMacTest";
2409 targetId.wifiIp = "wifiIpTest";
2410 pinType = static_cast<DmPinType>(6);
2411 ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2412 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2413 pinType = DmPinType::QR_CODE;
2414 payload.resize(DM_STRING_LENGTH_MAX * 2);
2415 ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2416 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2417 payload.resize(10);
2418 ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2419 ASSERT_EQ(ret, DM_OK);
2420 ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2421 ASSERT_EQ(ret, DM_OK);
2422 }
2423
2424 /**
2425 * @tc.name: DestroyPinHolder_001
2426 * @tc.desc: 1. set udid and bundleName not null
2427 * 2. call DeviceManagerImpl::DestroyPinHolder with parameter
2428 * 3. check ret is true
2429 * @tc.type: FUNC
2430 */
2431 HWTEST_F(DeviceManagerImplTest, DestoryPinHolder_001, testing::ext::TestSize.Level0)
2432 {
2433 std::string pkgName = "";
2434 PeerTargetId targetId;
2435 DmPinType pinType = DmPinType::QR_CODE;
2436 std::string payload = "payload";
2437 int32_t ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2438 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2439 pkgName = "com.ohos.test";
2440 targetId.deviceId = "deviceIdTest";
2441 targetId.brMac = "brMacTest";
2442 targetId.bleMac = "bleMacTest";
2443 targetId.wifiIp = "wifiIpTest";
2444 pinType = static_cast<DmPinType>(6);
2445 ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2446 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2447 pinType = DmPinType::QR_CODE;
2448 payload.resize(DM_STRING_LENGTH_MAX * 2);
2449 ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2450 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2451 payload.resize(10);
2452 ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2453 ASSERT_EQ(ret, DM_OK);
2454 ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2455 ASSERT_EQ(ret, DM_OK);
2456 }
2457
2458 /**
2459 * @tc.name: DpAclAdd_001
2460 * @tc.desc: 1. set DpAclAdd and Udid not null
2461 * 2. call DeviceManagerImpl::DpAclAdd with parameter
2462 * 3. check ret is true
2463 * @tc.type: FUNC
2464 */
2465 HWTEST_F(DeviceManagerImplTest, DpAclAdd_001, testing::ext::TestSize.Level0)
2466 {
2467 int64_t accessControlId = 0;
2468 std::string udid = "udidTest";
2469 int32_t bindType = PEER_TO_PEER;
2470 int32_t ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
2471 ASSERT_EQ(ret, DM_OK);
2472 bindType = IDENTICAL_ACCOUNT;
2473 ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
2474 ASSERT_EQ(ret, DM_OK);
2475 ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
2476 ASSERT_EQ(ret, DM_OK);
2477 }
2478
2479 /**
2480 * @tc.name: GetDeviceSecurityLevel_001
2481 * @tc.desc: 1. set DpAclAdd and Udid not null
2482 * 2. call DeviceManagerImpl::GetDeviceSecurityLevel with parameter
2483 * 3. check ret is true
2484 * @tc.type: FUNC
2485 */
2486 HWTEST_F(DeviceManagerImplTest, GetDeviceSecurityLevel_001, testing::ext::TestSize.Level0)
2487 {
2488 int32_t securityLevel = 3;
2489 std::string pkgName = "";
2490 std::string netWorkId = "";
2491 int32_t ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
2492 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2493 pkgName = "com.ohos.test";
2494 ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
2495 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2496 netWorkId = "netWorkIdTest";
2497 ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
2498 ASSERT_EQ(ret, DM_OK);
2499 pkgName = "";
2500 ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
2501 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2502 }
2503
2504 HWTEST_F(DeviceManagerImplTest, GetAllTrustedDeviceList_001, testing::ext::TestSize.Level0)
2505 {
2506 std::string pkgName = "";
2507 std::string extra = "extraInfo";
2508 std::vector<DmDeviceInfo> deviceList;
2509 int32_t ret = DeviceManager::GetInstance().GetAllTrustedDeviceList(pkgName, extra, deviceList);
2510 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2511
2512 pkgName = "p*******lo";
2513 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2514 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2515 ret = DeviceManager::GetInstance().GetAllTrustedDeviceList(pkgName, extra, deviceList);
2516 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2517
2518 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2519 .Times(1).WillOnce(testing::Return(DM_OK));
2520 ret = DeviceManager::GetInstance().GetAllTrustedDeviceList(pkgName, extra, deviceList);
2521 ASSERT_EQ(ret, DM_OK);
2522 }
2523
2524 HWTEST_F(DeviceManagerImplTest, RegisterLocalServiceInfo_001, testing::ext::TestSize.Level0)
2525 {
2526 DMLocalServiceInfo info;
2527 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2528 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2529 int32_t ret = DeviceManager::GetInstance().RegisterLocalServiceInfo(info);
2530 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2531
2532 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2533 .Times(1).WillOnce(testing::Return(DM_OK));
2534 ret = DeviceManager::GetInstance().RegisterLocalServiceInfo(info);
2535 ASSERT_EQ(ret, DM_OK);
2536 }
2537
2538 HWTEST_F(DeviceManagerImplTest, UnRegisterLocalServiceInfo_001, testing::ext::TestSize.Level0)
2539 {
2540 std::string bundleName = "b*********kl";
2541 int32_t pinExchangeType = 1;
2542 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2543 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2544 int32_t ret = DeviceManager::GetInstance().UnRegisterLocalServiceInfo(bundleName, pinExchangeType);
2545 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2546
2547 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2548 .Times(1).WillOnce(testing::Return(DM_OK));
2549 ret = DeviceManager::GetInstance().UnRegisterLocalServiceInfo(bundleName, pinExchangeType);
2550 ASSERT_EQ(ret, DM_OK);
2551 }
2552
2553 HWTEST_F(DeviceManagerImplTest, UpdateLocalServiceInfo_001, testing::ext::TestSize.Level0)
2554 {
2555 DMLocalServiceInfo info;
2556 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2557 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2558 int32_t ret = DeviceManager::GetInstance().UpdateLocalServiceInfo(info);
2559 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2560
2561 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2562 .Times(1).WillOnce(testing::Return(DM_OK));
2563 ret = DeviceManager::GetInstance().UpdateLocalServiceInfo(info);
2564 ASSERT_EQ(ret, DM_OK);
2565 }
2566
2567 HWTEST_F(DeviceManagerImplTest, GetLocalServiceInfoByBundleNameAndPinExchangeType_001, testing::ext::TestSize.Level0)
2568 {
2569 std::string bundleName = "b*********kl";
2570 int32_t pinExchangeType = 1;
2571 DMLocalServiceInfo info;
2572 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2573 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2574 int32_t ret = DeviceManager::GetInstance().GetLocalServiceInfoByBundleNameAndPinExchangeType(bundleName,
2575 pinExchangeType, info);
2576 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2577
2578 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
2579 .Times(1).WillOnce(testing::Return(DM_OK));
2580 ret = DeviceManager::GetInstance().GetLocalServiceInfoByBundleNameAndPinExchangeType(bundleName,
2581 pinExchangeType, info);
2582 ASSERT_EQ(ret, DM_OK);
2583 }
2584 } // namespace
2585 } // namespace DistributedHardware
2586 } // namespace OHOS
2587