1 /*
2 * Copyright (c) 2022-2023 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_dmfaparam_rsp.h"
26 #include "ipc_get_info_by_network_req.h"
27 #include "ipc_get_info_by_network_rsp.h"
28 #include "ipc_get_local_device_info_rsp.h"
29 #include "ipc_get_trustdevice_req.h"
30 #include "ipc_get_trustdevice_rsp.h"
31 #include "ipc_req.h"
32 #include "ipc_rsp.h"
33 #include "ipc_set_useroperation_req.h"
34 #include "ipc_skeleton.h"
35 #include "ipc_start_discovery_req.h"
36 #include "ipc_stop_discovery_req.h"
37 #include "ipc_publish_req.h"
38 #include "ipc_unpublish_req.h"
39 #include "ipc_unauthenticate_device_req.h"
40 #include "ipc_verify_authenticate_req.h"
41 #include "nativetoken_kit.h"
42 #include "securec.h"
43 #include "token_setproc.h"
44
45 namespace OHOS {
46 namespace DistributedHardware {
SetUp()47 void DeviceManagerImplTest::SetUp()
48 {
49 uint64_t tokenId;
50 const char *perms[2];
51 perms[0] = "ohos.permission.ACCESS_SERVICE_DM";
52 perms[1] = "ohos.permission.DISTRIBUTED_DATASYNC";
53 NativeTokenInfoParams infoInstance = {
54 .dcapsNum = 0,
55 .permsNum = 2,
56 .aclsNum = 0,
57 .dcaps = NULL,
58 .perms = perms,
59 .acls = NULL,
60 .processName = "dsoftbus_service",
61 .aplStr = "system_core",
62 };
63 tokenId = GetAccessTokenId(&infoInstance);
64 SetSelfTokenID(tokenId);
65 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
66 }
67
TearDown()68 void DeviceManagerImplTest::TearDown()
69 {
70 }
71
SetUpTestCase()72 void DeviceManagerImplTest::SetUpTestCase()
73 {
74 }
75
TearDownTestCase()76 void DeviceManagerImplTest::TearDownTestCase()
77 {
78 }
79
80 namespace {
81 /**
82 * @tc.name: InitDeviceManager_001
83 * @tc.desc: 1. set packName not null
84 * set dmInitCallback not null
85 * 2. call DeviceManagerImpl::InitDeviceManager with parameter
86 * 4. check ret is DM_OK
87 * deviceTypeId
88 * @tc.type: FUNC
89 * @tc.require: AR000GHSJK
90 */
91 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_101, testing::ext::TestSize.Level0)
92 {
93 // 1. set packName not null
94 std::string packName = "com.ohos.test";
95 // set dmInitCallback not null
96 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
97 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
98 // 3. check ret is DM_OK
99 ASSERT_EQ(ret, DM_OK);
100 DeviceManager::GetInstance().UnInitDeviceManager(packName);
101 }
102
103 /**
104 * @tc.name: UnInitDeviceManager_101
105 * @tc.desc: 1. set packName not null
106 * 2. MOCK IpcClientProxy UnInit return DM_OK
107 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
108 * 4. check ret is DM_OK
109 * deviceTypeId
110 * @tc.type: FUNC
111 * @tc.require: AR000GHSJK
112 */
113 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_101, testing::ext::TestSize.Level0)
114 {
115 std::string packName = "com.ohos.test2";
116 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
117 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
118 ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
119 ASSERT_EQ(ret, DM_OK);
120 }
121
122 /**
123 * @tc.name: GetTrustedDeviceList_101
124 * @tc.desc: 1. set packName not null
125 * set extra null
126 * set deviceList null
127 * 2. MOCK IpcClientProxy SendRequest return DM_OK
128 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
129 * 4. check ret is DM_OK
130 * deviceTypeId
131 * @tc.type: FUNC
132 * @tc.require: AR000GHSJK
133 */
134 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_101, testing::ext::TestSize.Level0)
135 {
136 // 1. set packName not null
137 std::string packName = "com.ohos.test";
138 // set extra null
139 std::string extra = "";
140 // set deviceList null
141 std::vector<DmDeviceInfo> deviceList;
142 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
143 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
144 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
145 ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
146 // 3. check ret is DM_OK
147 ASSERT_EQ(ret, DM_OK);
148 DeviceManager::GetInstance().UnInitDeviceManager(packName);
149 }
150
151 /**
152 * @tc.name: GetAvailableDeviceList_101
153 * @tc.desc: 1. set packName null
154 * set deviceList null
155 * 2. call DeviceManagerImpl::GetAvailableDeviceList with parameter
156 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
157 * deviceTypeId
158 * @tc.type: FUNC
159 */
160 HWTEST_F(DeviceManagerImplTest, GetAvailableDeviceList_101, testing::ext::TestSize.Level0)
161 {
162 std::string packName;
163 std::vector<DmDeviceBasicInfo> deviceList;
164 int32_t ret = DeviceManager::GetInstance().GetAvailableDeviceList(packName, deviceList);
165 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
166 }
167
168 /**
169 * @tc.name: GetAvailableDeviceList_102
170 * @tc.desc: 1. set packName not null
171 * set deviceList null
172 * 2. InitDeviceManager return DM_OK
173 * 3. call DeviceManagerImpl::GetAvailableDeviceList with parameter
174 * 4. check ret is DM_OK
175 * deviceTypeId
176 * @tc.type: FUNC
177 */
178 HWTEST_F(DeviceManagerImplTest, GetAvailableDeviceList_102, testing::ext::TestSize.Level0)
179 {
180 std::string packName = "com.ohos.test";
181 std::vector<DmDeviceBasicInfo> deviceList;
182 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
183 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
184 ret = DeviceManager::GetInstance().GetAvailableDeviceList(packName, deviceList);
185 ASSERT_EQ(ret, DM_OK);
186 DeviceManager::GetInstance().UnInitDeviceManager(packName);
187 }
188
189 /**
190 * @tc.name: GetLocalDeviceNetWorkId_101
191 * @tc.desc: 1. set packName null
192 * set networkId null
193 * 2. call DeviceManagerImpl::GetLocalDeviceNetWorkId with parameter
194 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
195 * deviceTypeId
196 * @tc.type: FUNC
197 */
198 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceNetWorkId_101, testing::ext::TestSize.Level0)
199 {
200 std::string packName;
201 std::string networkId;
202 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceNetWorkId(packName, networkId);
203 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
204 }
205
206 /**
207 * @tc.name: GetLocalDeviceNetWorkId_102
208 * @tc.desc: 1. set packName not null
209 * set networkId not null
210 * 2. InitDeviceManager return DM_OK
211 * 3. call DeviceManagerImpl::GetLocalDeviceNetWorkId with parameter
212 * 4. check ret is DM_OK
213 * deviceTypeId
214 * @tc.type: FUNC
215 */
216 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceNetWorkId_102, testing::ext::TestSize.Level0)
217 {
218 std::string packName = "com.ohos.test";
219 std::string networkId = "networkId";
220 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
221 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
222 ret = DeviceManager::GetInstance().GetLocalDeviceNetWorkId(packName, networkId);
223 ASSERT_EQ(ret, DM_OK);
224 DeviceManager::GetInstance().UnInitDeviceManager(packName);
225 }
226
227 /**
228 * @tc.name: GetLocalDeviceId_101
229 * @tc.desc: 1. set packName null
230 * set deviceId null
231 * 2. call DeviceManagerImpl::GetLocalDeviceId with parameter
232 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
233 * deviceTypeId
234 * @tc.type: FUNC
235 */
236 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceId_101, testing::ext::TestSize.Level0)
237 {
238 std::string packName;
239 std::string deviceId;
240 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceId(packName, deviceId);
241 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
242 }
243
244 /**
245 * @tc.name: GetLocalDeviceId_102
246 * @tc.desc: 1. set packName not null
247 * set deviceId not null
248 * 2. InitDeviceManager return DM_OK
249 * 3. call DeviceManagerImpl::GetLocalDeviceId with parameter
250 * 4. check ret is DM_OK
251 * deviceTypeId
252 * @tc.type: FUNC
253 */
254 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceId_102, testing::ext::TestSize.Level0)
255 {
256 std::string packName = "com.ohos.test";
257 std::string deviceId = "deviceId";
258 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
259 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
260 ret = DeviceManager::GetInstance().GetLocalDeviceId(packName, deviceId);
261 ASSERT_EQ(ret, DM_OK);
262 DeviceManager::GetInstance().UnInitDeviceManager(packName);
263 }
264
265 /**
266 * @tc.name: GetLocalDeviceName_101
267 * @tc.desc: 1. set packName null
268 * set deviceName null
269 * 2. call DeviceManagerImpl::GetLocalDeviceName with parameter
270 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
271 * deviceTypeId
272 * @tc.type: FUNC
273 */
274 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_101, testing::ext::TestSize.Level0)
275 {
276 std::string packName;
277 std::string deviceName;
278 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceName(packName, deviceName);
279 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
280 }
281
282 /**
283 * @tc.name: GetLocalDeviceName_102
284 * @tc.desc: 1. set packName not null
285 * set deviceName not null
286 * 2. InitDeviceManager return DM_OK
287 * 3. call DeviceManagerImpl::GetLocalDeviceName with parameter
288 * 4. check ret is DM_OK
289 * deviceTypeId
290 * @tc.type: FUNC
291 */
292 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_102, testing::ext::TestSize.Level0)
293 {
294 std::string packName = "com.ohos.test";
295 std::string deviceName = "deviceName";
296 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
297 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
298 ret = DeviceManager::GetInstance().GetLocalDeviceName(packName, deviceName);
299 ASSERT_EQ(ret, DM_OK);
300 DeviceManager::GetInstance().UnInitDeviceManager(packName);
301 }
302
303
304 /**
305 * @tc.name: GetLocalDeviceType_101
306 * @tc.desc: 1. set packName null
307 * set deviceType 0
308 * 2. call DeviceManagerImpl::GetLocalDeviceType with parameter
309 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
310 * deviceTypeId
311 * @tc.type: FUNC
312 */
313 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceType_101, testing::ext::TestSize.Level0)
314 {
315 std::string packName;
316 int32_t deviceType = 0;
317 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceType(packName, deviceType);
318 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
319 }
320
321 /**
322 * @tc.name: GetLocalDeviceType_102
323 * @tc.desc: 1. set packName not null
324 * set deviceType 0
325 * 2. InitDeviceManager return DM_OK
326 * 3. call DeviceManagerImpl::GetLocalDeviceType with parameter
327 * 4. check ret is DM_OK
328 * deviceTypeId
329 * @tc.type: FUNC
330 */
331 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceType_102, testing::ext::TestSize.Level0)
332 {
333 std::string packName = "com.ohos.test";
334 int32_t deviceType = 0;
335 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
336 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
337 ret = DeviceManager::GetInstance().GetLocalDeviceType(packName, deviceType);
338 ASSERT_EQ(ret, DM_OK);
339 DeviceManager::GetInstance().UnInitDeviceManager(packName);
340 }
341
342 /**
343 * @tc.name: GetDeviceName_101
344 * @tc.desc: 1. set packName null
345 * set networkId not null
346 * set deviceName null
347 * 3. call DeviceManagerImpl::GetDeviceName with parameter
348 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
349 * deviceTypeId
350 * @tc.type: FUNC
351 */
352 HWTEST_F(DeviceManagerImplTest, GetDeviceName_101, testing::ext::TestSize.Level0)
353 {
354 std::string packName;
355 std::string networkId = "networkId";
356 std::string deviceName;
357 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
358 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
359 }
360
361 /**
362 * @tc.name: GetDeviceName_102
363 * @tc.desc: 1. set packName not null
364 * set networkId null
365 * set deviceName null
366 * 2. call DeviceManagerImpl::GetDeviceName with parameter
367 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
368 * deviceTypeId
369 * @tc.type: FUNC
370 */
371 HWTEST_F(DeviceManagerImplTest, GetDeviceName_102, testing::ext::TestSize.Level0)
372 {
373 std::string packName = "com.ohos.test";
374 std::string networkId;
375 std::string deviceName;
376 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
377 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
378 }
379
380 /**
381 * @tc.name: GetDeviceName_103
382 * @tc.desc: 1. set packName not null
383 * set networkId not null
384 * set deviceName null
385 * 2. call DeviceManagerImpl::GetDeviceName with parameter
386 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
387 * deviceTypeId
388 * @tc.type: FUNC
389 */
390 HWTEST_F(DeviceManagerImplTest, GetDeviceName_103, testing::ext::TestSize.Level0)
391 {
392 std::string packName = "com.ohos.test";
393 std::string networkId = "networkId";
394 std::string deviceName;
395 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
396 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
397 }
398
399 /**
400 * @tc.name: GetDeviceName_104
401 * @tc.desc: 1. set packName not null
402 * set networkId not null
403 * set deviceName null
404 * 2. InitDeviceManager return DM_OK
405 * 3. call DeviceManagerImpl::GetDeviceName with parameter
406 * 4. check ret is DM_OK
407 * deviceTypeId
408 * @tc.type: FUNC
409 */
410 HWTEST_F(DeviceManagerImplTest, GetDeviceName_104, testing::ext::TestSize.Level0)
411 {
412 std::string packName = "com.ohos.test";
413 std::string networkId = "networkId";
414 std::string deviceName;
415 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
416 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
417 ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
418 ASSERT_EQ(ret, DM_OK);
419 DeviceManager::GetInstance().UnInitDeviceManager(packName);
420 }
421
422 /**
423 * @tc.name: GetDeviceType_101
424 * @tc.desc: 1. set packName null
425 * set deviceList not null
426 * set deviceType 0
427 * 2. call DeviceManagerImpl::GetDeviceType with parameter
428 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
429 * deviceTypeId
430 * @tc.type: FUNC
431 */
432 HWTEST_F(DeviceManagerImplTest, GetDeviceType_101, testing::ext::TestSize.Level0)
433 {
434 std::string packName;
435 std::string networkId = "networkId";
436 int32_t deviceType = 0;
437 int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
438 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
439 }
440
441 /**
442 * @tc.name: GetDeviceType_102
443 * @tc.desc: 1. set packName not null
444 * set networkId 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_102, testing::ext::TestSize.Level0)
452 {
453 std::string packName = "com.ohos.test";
454 std::string 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_103
462 * @tc.desc: 1. set packName not null
463 * set networkId not null
464 * set deviceType 0
465 * 2. call DeviceManagerImpl::GetDeviceType with parameter
466 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
467 * deviceTypeId
468 * @tc.type: FUNC
469 */
470 HWTEST_F(DeviceManagerImplTest, GetDeviceType_103, testing::ext::TestSize.Level0)
471 {
472 std::string packName = "com.ohos.test";
473 std::string networkId = "networkId";
474 int32_t deviceType = 0;
475 int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
476 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
477 }
478
479 /**
480 * @tc.name: GetDeviceType_104
481 * @tc.desc: 1. set packName not null
482 * set networkId not null
483 * set deviceType 0
484 * 2. InitDeviceManager return DM_OK
485 * 3. call DeviceManagerImpl::GetDeviceType with parameter
486 * 4. check ret is DM_OK
487 * deviceTypeId
488 * @tc.type: FUNC
489 */
490 HWTEST_F(DeviceManagerImplTest, GetDeviceType_104, testing::ext::TestSize.Level0)
491 {
492 std::string packName = "com.ohos.test";
493 std::string networkId = "networkId";
494 int32_t deviceType = 0;
495 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
496 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
497 ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
498 ASSERT_EQ(ret, DM_OK);
499 DeviceManager::GetInstance().UnInitDeviceManager(packName);
500 }
501
502 /**
503 * @tc.name: UnBindDevice_101
504 * @tc.desc: 1. set packName null
505 * set deviceId not null
506 * 2. call DeviceManagerImpl::UnBindDevice with parameter
507 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
508 * deviceTypeId
509 * @tc.type: FUNC
510 */
511 HWTEST_F(DeviceManagerImplTest, UnBindDevice_101, testing::ext::TestSize.Level0)
512 {
513 std::string packName ;
514 std::string deviceId = "deviceId";
515 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
516 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
517 }
518
519 /**
520 * @tc.name: UnBindDevice_102
521 * @tc.desc: 1. set packName not null
522 * set deviceId null
523 * 2. call DeviceManagerImpl::UnBindDevice with parameter
524 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
525 * deviceTypeId
526 * @tc.type: FUNC
527 */
528 HWTEST_F(DeviceManagerImplTest, UnBindDevice_102, testing::ext::TestSize.Level0)
529 {
530 std::string packName = "com.ohos.test";
531 std::string deviceId;
532 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
533 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
534 }
535
536 /**
537 * @tc.name: UnBindDevice_103
538 * @tc.desc: 1. set packName not null
539 * set deviceId not null
540 * 2. call DeviceManagerImpl::UnBindDevice with parameter
541 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
542 * deviceTypeId
543 * @tc.type: FUNC
544 */
545 HWTEST_F(DeviceManagerImplTest, UnBindDevice_103, testing::ext::TestSize.Level0)
546 {
547 std::string packName = "com.ohos.test";
548 std::string deviceId = "deviceId";
549 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
550 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
551 }
552
553 /**
554 * @tc.name: UnBindDevice_104
555 * @tc.desc: 1. set packName not null
556 * set deviceId not null
557 * 2. InitDeviceManager return DM_OK
558 * 3. call DeviceManagerImpl::UnBindDevice with parameter
559 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
560 * deviceTypeId
561 * @tc.type: FUNC
562 */
563 HWTEST_F(DeviceManagerImplTest, UnBindDevice_104, testing::ext::TestSize.Level0)
564 {
565 std::string packName = "com.ohos.test";
566 std::string deviceId = "deviceId";
567 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
568 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
569 ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
570 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
571 DeviceManager::GetInstance().UnInitDeviceManager(packName);
572 }
573
574 /**
575 * @tc.name: BindDevice_101
576 * @tc.desc: 1. set packName null
577 * set bindType 0
578 * set deviceId not null
579 * set bindParam null
580 * set callback null
581 * 2. call DeviceManagerImpl::BindDevice with parameter
582 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
583 * deviceTypeId
584 * @tc.type: FUNC
585 */
586 HWTEST_F(DeviceManagerImplTest, BindDevice_101, testing::ext::TestSize.Level0)
587 {
588 std::string packName ;
589 int32_t bindType = 0;
590 std::string deviceId = "deviceId";
591 std::string bindParam;
592 std::shared_ptr<AuthenticateCallback> callback = nullptr;
593 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
594 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
595 }
596
597 /**
598 * @tc.name: BindDevice_102
599 * @tc.desc: 1. set packName not null
600 * set bindType 0
601 * set deviceId null
602 * set bindParam null
603 * set callback null
604 * 2. call DeviceManagerImpl::BindDevice with parameter
605 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
606 * deviceTypeId
607 * @tc.type: FUNC
608 */
609 HWTEST_F(DeviceManagerImplTest, BindDevice_102, testing::ext::TestSize.Level0)
610 {
611 std::string packName = "com.ohos.test";
612 int32_t bindType = 0;
613 std::string deviceId;
614 std::string bindParam;
615 std::shared_ptr<AuthenticateCallback> callback = nullptr;
616 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
617 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
618 }
619
620 /**
621 * @tc.name: BindDevice_103
622 * @tc.desc: 1. set packName not null
623 * set bindType 0
624 * set deviceId not null
625 * set bindParam null
626 * set callback null
627 * 2. call DeviceManagerImpl::BindDevice with parameter
628 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
629 * deviceTypeId
630 * @tc.type: FUNC
631 */
632 HWTEST_F(DeviceManagerImplTest, BindDevice_103, testing::ext::TestSize.Level0)
633 {
634 std::string packName = "com.ohos.test";
635 int32_t bindType = 0;
636 std::string deviceId = "deviceId";
637 std::string bindParam;
638 std::shared_ptr<AuthenticateCallback> callback = nullptr;
639 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
640 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
641 }
642
643 /**
644 * @tc.name: BindDevice_104
645 * @tc.desc: 1. set packName not null
646 * set bindType 0
647 * set deviceId not null
648 * set bindParam null
649 * set callback null
650 * 2. InitDeviceManager return DM_OK
651 * 3. call DeviceManagerImpl::BindDevice with parameter
652 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
653 * deviceTypeId
654 * @tc.type: FUNC
655 */
656 HWTEST_F(DeviceManagerImplTest, BindDevice_104, testing::ext::TestSize.Level0)
657 {
658 std::string packName = "com.ohos.test";
659 int32_t bindType = 0;
660 std::string deviceId = "deviceId";
661 std::string bindParam;
662 std::shared_ptr<AuthenticateCallback> callback = nullptr;
663 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
664 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
665 ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
666 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
667 DeviceManager::GetInstance().UnInitDeviceManager(packName);
668 }
669
670 /**
671 * @tc.name: RegisterDevStateCallback_101
672 * @tc.desc: 1. set packName not null
673 * set extra not null
674 * set callback not null
675 * 2. InitDeviceManager return DM_OK
676 * 3. call DeviceManagerImpl::RegisterDevStateCallback with parameter
677 * 4. check ret is DM_OK
678 * deviceTypeId
679 * @tc.type: FUNC
680 */
681 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_101, testing::ext::TestSize.Level0)
682 {
683 std::string packName = "com.ohos.test";
684 std::string extra = "extra";
685 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>();
686 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
687 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
688 ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
689 ASSERT_EQ(ret, DM_OK);
690 DeviceManager::GetInstance().UnInitDeviceManager(packName);
691 }
692
693 /**
694 * @tc.name: RegisterDevStateCallback_102
695 * @tc.desc: 1. set packName null
696 * set extra not null
697 * set callback not null
698 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
699 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
700 * deviceTypeId
701 * @tc.type: FUNC
702 */
703 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_102, testing::ext::TestSize.Level0)
704 {
705 std::string packName;
706 std::string extra = "extra";
707 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>();
708 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
709 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
710 }
711
712 /**
713 * @tc.name: RegisterDevStateCallback_103
714 * @tc.desc: 1. set packName null
715 * set extra not null
716 * set callback not null
717 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
718 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
719 * deviceTypeId
720 * @tc.type: FUNC
721 */
722 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_103, testing::ext::TestSize.Level0)
723 {
724 std::string packName = "com.ohos.test";
725 std::string extra = "extra";
726 std::shared_ptr<DeviceStateCallback> callback = nullptr;
727 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
728 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
729 }
730
731 /**
732 * @tc.name: UnRegisterDevStateCallback_101
733 * @tc.desc: 1. set packName not null
734 * 2. InitDeviceManager return DM_OK
735 * 3. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
736 * 4. check ret is DM_OK
737 * deviceTypeId
738 * @tc.type: FUNC
739 */
740 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallbackk_101, testing::ext::TestSize.Level0)
741 {
742 std::string packName = "com.ohos.test";
743 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
744 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
745 ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
746 ASSERT_EQ(ret, DM_OK);
747 DeviceManager::GetInstance().UnInitDeviceManager(packName);
748 }
749
750 /**
751 * @tc.name: UnRegisterDevStateCallback_102
752 * @tc.desc: 1. set packName null
753 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
754 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
755 * deviceTypeId
756 * @tc.type: FUNC
757 */
758 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_102, testing::ext::TestSize.Level0)
759 {
760 std::string packName;
761 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
762 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
763 }
764
765 /**
766 * @tc.name: GetLocalDeviceInfo_101
767 * @tc.desc: 1. set packName null
768 * set extra null
769 * set deviceList null
770 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
771 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
772 * deviceTypeId
773 * @tc.type: FUNC
774 * @tc.require: AR000GHSJK
775 */
776 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_101, testing::ext::TestSize.Level0)
777 {
778 // 1. set packName not null
779 std::string packName = "com.ohos.test";
780 // set extra null
781 DmDeviceInfo info;
782 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
783 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
784 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
785 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
786 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
787 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
788 ASSERT_EQ(ret, DM_OK);
789 DeviceManager::GetInstance().UnInitDeviceManager(packName);
790 }
791
792 /**
793 * @tc.name: StartDeviceDiscovery_101
794 * @tc.desc: 1. set packName not null
795 * set subscribeInfo null
796 * set callback not null
797 * 2. InitDeviceManager return DM_OK
798 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
799 * 4. check ret is ERR_DM_DISCOVERY_FAILED
800 * deviceTypeId
801 * @tc.type: FUNC
802 * @tc.require: AR000GHSJK
803 */
804 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_101, testing::ext::TestSize.Level0)
805 {
806 // 1. set packName not null
807 std::string packName = "com.ohos.helloworld";
808 std::string extra= "";
809 // set subscribeInfo null
810 DmSubscribeInfo subscribeInfo;
811 // set callback not null
812 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
813 // 2. InitDeviceManager return DM_OK
814 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
815 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
816 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
817 ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
818 // 4. check ret is ERR_DM_DISCOVERY_FAILED
819 ASSERT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
820 DeviceManager::GetInstance().UnInitDeviceManager(packName);
821 }
822
823 /**
824 * @tc.name: StartDeviceDiscovery_102
825 * @tc.desc: 1. set packName not null
826 * set subscribeId 0
827 * set filterOptions null
828 * set callback not null
829 * 2. InitDeviceManager return DM_OK
830 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
831 * 4. check ret is ERR_DM_DISCOVERY_REPEATED
832 * deviceTypeId
833 * @tc.type: FUNC
834 * @tc.require: AR000GHSJK
835 */
836 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_102, testing::ext::TestSize.Level0)
837 {
838 std::string packName = "com.ohos.helloworld";
839 uint16_t subscribeId = 0;
840 std::string filterOptions;
841 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
842 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
843 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
844 ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
845 ASSERT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
846 DeviceManager::GetInstance().UnInitDeviceManager(packName);
847 }
848
849 /**
850 * @tc.name: StartDeviceDiscovery_103
851 * @tc.desc: 1. set packName not null
852 * set subscribeId 0
853 * set filterOptions null
854 * set callback not null
855 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
856 * 3. check ret is ERR_DM_DISCOVERY_REPEATED
857 * deviceTypeId
858 * @tc.type: FUNC
859 * @tc.require: AR000GHSJK
860 */
861 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_103, testing::ext::TestSize.Level0)
862 {
863 std::string packName = "com.ohos.helloworld";
864 uint16_t subscribeId = 0;
865 std::string filterOptions;
866 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
867 DmDeviceInfo deviceInfo;
868 callback->OnDeviceFound(subscribeId, deviceInfo);
869 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
870 ASSERT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
871 }
872
873 /**
874 * @tc.name: StopDeviceDiscovery_101
875 * @tc.desc: 1. set packName not null
876 * set subscribeId is 0
877 * 2. InitDeviceManager return DM_OK
878 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
879 * 4. check ret is ERR_DM_DISCOVERY_FAILED
880 * deviceTypeId
881 * @tc.type: FUNC
882 * @tc.require: AR000GHSJK
883 */
884 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_101, testing::ext::TestSize.Level0)
885 {
886 // 1. set packName not null
887 std::string packName = "com.ohos.test";
888 // set subscribeInfo is 0
889 uint16_t subscribeId = 0;
890 // 2. InitDeviceManager return DM_OK
891 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
892 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
893 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
894 ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
895 // 4. check ret is DM_OK
896 ASSERT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
897 DeviceManager::GetInstance().UnInitDeviceManager(packName);
898 }
899
900 /**
901 * @tc.name: PublishDeviceDiscovery_101
902 * @tc.desc: 1. set packName not null
903 * set publishInfo null
904 * set callback not null
905 * 2. InitDeviceManager return DM_OK
906 * 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
907 * 4. check ret is ERR_DM_PUBLISH_FAILED
908 * deviceTypeId
909 * @tc.type: FUNC
910 * @tc.require: I5N1K3
911 */
912 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_101, testing::ext::TestSize.Level0)
913 {
914 // 1. set packName not null
915 std::string packName = "com.ohos.helloworld";
916 // set publishInfo null
917 DmPublishInfo publishInfo;
918 // set callback not null
919 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
920 // 2. InitDeviceManager return DM_OK
921 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
922 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
923 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
924 ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
925 // 4. check ret is ERR_DM_PUBLISH_FAILED
926 ASSERT_EQ(ret, ERR_DM_PUBLISH_FAILED);
927 DeviceManager::GetInstance().UnInitDeviceManager(packName);
928 }
929
930 /**
931 * @tc.name: UnPublishDeviceDiscovery_101
932 * @tc.desc: 1. set packName not null
933 * set publishId is 0
934 * 2. InitDeviceManager return DM_OK
935 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
936 * 4. check ret is ERR_DM_PUBLISH_FAILED
937 * deviceTypeId
938 * @tc.type: FUNC
939 * @tc.require: I5N1K3
940 */
941 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_101, testing::ext::TestSize.Level0)
942 {
943 // 1. set packName not null
944 std::string packName = "com.ohos.test";
945 // set subscribeInfo is 0
946 int32_t publishId = 0;
947 // 2. InitDeviceManager return DM_OK
948 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
949 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
950 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
951 ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
952 // 4. check ret is ERR_DM_PUBLISH_FAILED
953 ASSERT_EQ(ret, ERR_DM_PUBLISH_FAILED);
954 DeviceManager::GetInstance().UnInitDeviceManager(packName);
955 }
956
957 /**
958 * @tc.name: AuthenticateDevice_101
959 * @tc.desc: 1. set packName not null
960 * set dmDeviceInfo null
961 * set dmAppImageInfo null
962 * set extra null
963 * set callback null
964 * 2. InitDeviceManager return DM_OK
965 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
966 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
967 * deviceTypeId
968 * @tc.type: FUNC
969 * @tc.require: AR000GHSJK
970 */
971 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_101, testing::ext::TestSize.Level0)
972 {
973 // 1. set packName not null
974 std::string packName = "com.ohos.helloworld";
975 // set dmDeviceInfo null
976 int32_t authType = 1;
977 // set dmAppImageInfo null
978 DmDeviceInfo dmDeviceInfo;
979 strcpy_s(dmDeviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, "123XXXX");
980 strcpy_s(dmDeviceInfo.deviceName, DM_MAX_DEVICE_NAME_LEN, "234");
981 dmDeviceInfo.deviceTypeId = 0;
982 // set extra null
983 std::string extra = "test";
984 // set callback null
985 std::shared_ptr<AuthenticateCallback> callback = nullptr;
986 // 2.InitDeviceManager return DM_OK
987 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
988 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
989 ASSERT_EQ(ret, DM_OK);
990 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
991 ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
992 // 4. check ret is DM_OK
993 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
994 DeviceManager::GetInstance().UnInitDeviceManager(packName);
995 }
996
997 /**
998 * @tc.name: UnAuthenticateDevice_101
999 * @tc.desc: 1. set packName not null
1000 * set dmDeviceInfo null
1001 * set dmAppImageInfo null
1002 * set extra null
1003 * set callback null
1004 * 2. InitDeviceManager return DM_OK
1005 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1006 * 4. check ret is ERR_DM_FAILED
1007 * deviceTypeId
1008 * @tc.type: FUNC
1009 * @tc.require: AR000GHSJK
1010 */
1011 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_101, testing::ext::TestSize.Level0)
1012 {
1013 // 1. set packName not null
1014 std::string packName = "com.ohos.helloworld";
1015 DmDeviceInfo deviceInfo;
1016 deviceInfo.networkId[0] = '1';
1017 deviceInfo.networkId[1] = '2';
1018 deviceInfo.networkId[2] = '\0';
1019 // set callback null
1020 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1021 // 2. InitDeviceManager return DM_OK
1022 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
1023 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
1024 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1025 ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
1026 // 4. check ret is ERR_DM_FAILED
1027 ASSERT_EQ(ret, ERR_DM_FAILED);
1028 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1029 }
1030
1031 /**
1032 * @tc.name: SetUserOperation_101
1033 * @tc.desc: 1. set packName not null
1034 * set action null
1035 * 2. InitDeviceManager return DM_OK
1036 * 3. call DeviceManagerImpl::SetUserOperation with parameter
1037 * 4. check ret is DM_OK
1038 * deviceTypeId
1039 * @tc.type: FUNC
1040 * @tc.require: AR000GHSJK
1041 */
1042 HWTEST_F(DeviceManagerImplTest, SetUserOperation_101, testing::ext::TestSize.Level0)
1043 {
1044 // 1. set packName not null
1045 std::string packName = "com.ohos.test";
1046 // set authParam null
1047 int32_t action = 0;
1048 const std::string param = "extra";
1049 // 2. InitDeviceManager return DM_OK
1050 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1051 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1052 // 3. call DeviceManagerImpl::SetUserOperation with parameter
1053 ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
1054 // 4. check ret is DM_OK
1055 ASSERT_EQ(ret, DM_OK);
1056 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1057 }
1058
1059 /**
1060 * @tc.name: InitDeviceManager_001
1061 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt
1062 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
1063 * deviceTypeId
1064 * @tc.type: FUNC
1065 * @tc.require: AR000GHSJK
1066 */
1067 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_001, testing::ext::TestSize.Level0)
1068 {
1069 // 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt
1070 std::string packName = "";
1071 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr;
1072 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, dmInitCallback);
1073 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1074 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1075 }
1076
1077 /**
1078 * @tc.name: InitDeviceManager_002
1079 * @tc.desc: 1. set packName not null
1080 * set dmInitCallback not null
1081 * 2. call DeviceManagerImpl::InitDeviceManager with parameter
1082 * 3. check ret is DM_OK
1083 * deviceTypeId
1084 * @tc.type: FUNC
1085 * @tc.require: AR000GHSJK
1086 */
1087 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_002, testing::ext::TestSize.Level0)
1088 {
1089 // 1. set packName not null
1090 std::string packName = "com.ohos.test";
1091 // set dmInitCallback not null
1092 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1093 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1094 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1095 // 3. check ret is DM_OK
1096 ASSERT_EQ(ret, DM_OK);
1097 }
1098
1099 /**
1100 * @tc.name: InitDeviceManager_003
1101 * @tc.desc: 1. set packName not null
1102 * set dmInitCallback not null
1103 * 2. MOCK IpcClientProxy Init return ERR_DM_INIT_FAILED
1104 * 3. call DeviceManagerImpl::InitDeviceManager with parameter
1105 * 4. check ret is ERR_DM_INIT_FAILED
1106 * deviceTypeId
1107 * @tc.type: FUNC
1108 * @tc.require: AR000GHSJK
1109 */
1110 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_003, testing::ext::TestSize.Level0)
1111 {
1112 // 1. set packName not null
1113 std::string packName = "com.ohos.test";
1114 // set dmInitCallback not null
1115 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1116 // 2. MOCK IpcClientProxy Init return ERR_DM_FAILED
1117 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1118 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1119 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1120 EXPECT_CALL(*mockInstance, Init(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1121 // 3. call DeviceManagerImpl::InitDeviceManager with parameter
1122 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1123 // 4. check ret is ERR_DM_INIT_FAILED
1124 ASSERT_EQ(ret, ERR_DM_INIT_FAILED);
1125 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1126 }
1127
1128 /**
1129 * @tc.name: InitDeviceManager_004
1130 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1131 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
1132 * deviceTypeId
1133 * @tc.type: FUNC
1134 * @tc.require: AR000GHSJK
1135 */
1136 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_004, testing::ext::TestSize.Level0)
1137 {
1138 // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1139 std::string packName = "com.ohos.test";
1140 std::shared_ptr<DmInitCallbackTest> callback = nullptr;
1141 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1142 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1143 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1144 }
1145
1146 /**
1147 * @tc.name: InitDeviceManager_005
1148 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1149 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
1150 * deviceTypeId
1151 * @tc.type: FUNC
1152 * @tc.require: AR000GHSJK
1153 */
1154 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_005, testing::ext::TestSize.Level0)
1155 {
1156 // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1157 std::string packName = "";
1158 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1159 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1160 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1161 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1162 }
1163
1164 /**
1165 * @tc.name: UnInitDeviceManager_001
1166 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1167 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
1168 * deviceTypeId
1169 * @tc.type: FUNC
1170 * @tc.require: AR000GHSJK
1171 */
1172 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_001, testing::ext::TestSize.Level0)
1173 {
1174 // 1. set packName not null
1175 std::string packName = "";
1176 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1177 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1178 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1179 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1180 }
1181
1182 /**
1183 * @tc.name: UnInitDeviceManager_002
1184 * @tc.desc: 1. set packName not null
1185 * 2. MOCK IpcClientProxy UnInit return ERR_DM_FAILED
1186 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1187 * 4. check ret is ERR_DM_FAILED
1188 * deviceTypeId
1189 * @tc.type: FUNC
1190 * @tc.require: AR000GHSJK
1191 */
1192 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_002, testing::ext::TestSize.Level0)
1193 {
1194 // 1. set packName not null
1195 std::string packName = "com.ohos.test";
1196 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1197 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1198 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1199 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1200 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1201 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1202 // 3. check ret is ERR_DM_FAILED
1203 ASSERT_EQ(ret, ERR_DM_FAILED);
1204 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1205 }
1206
1207 /**
1208 * @tc.name: UnInitDeviceManager_003
1209 * @tc.desc: 1. set packName not null
1210 * 2. MOCK IpcClientProxy UnInit return DM_OK
1211 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1212 * 4. check ret is DM_OK
1213 * deviceTypeId
1214 * @tc.type: FUNC
1215 * @tc.require: AR000GHSJK
1216 */
1217 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_003, testing::ext::TestSize.Level0)
1218 {
1219 // 1. set packName not null
1220 std::string packName = "com.ohos.test";
1221 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1222 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1223 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1224 ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1225 // 3. check ret is DM_OK
1226 ASSERT_EQ(ret, DM_OK);
1227 }
1228
1229 /**
1230 * @tc.name: UnInitDeviceManager_004
1231 * @tc.desc: 1. set packName not null
1232 * 2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED
1233 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1234 * 4. check ret is ERR_DM_FAILED
1235 * deviceTypeId
1236 * @tc.type: FUNC
1237 * @tc.require: AR000GHSJK
1238 */
1239 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_004, testing::ext::TestSize.Level0)
1240 {
1241 // 1. set packNamen not null
1242 std::string packName = "com.ohos.test";
1243 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1244 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1245 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1246 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1247 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1248 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1249 // 3. check ret is ERR_DM_FAILED
1250 ASSERT_EQ(ret, ERR_DM_FAILED);
1251 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1252 }
1253
1254 /**
1255 * @tc.name: UnInitDeviceManager_005
1256 * @tc.desc: 1. set packName not null
1257 * 2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED
1258 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1259 * 4. check ret is ERR_DM_FAILED
1260 * deviceTypeId
1261 * @tc.type: FUNC
1262 * @tc.require: AR000GHSJK
1263 */
1264 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_005, testing::ext::TestSize.Level0)
1265 {
1266 // 1. set packName not null
1267 std::string packName = "com.ohos.test";
1268 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1269 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1270 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1271 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1272 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1273 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1274 // 3. check ret is ERR_DM_FAILED
1275 ASSERT_EQ(ret, ERR_DM_FAILED);
1276 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1277 }
1278
1279 /**
1280 * @tc.name: GetTrustedDeviceList_001
1281 * @tc.desc: 1. set packName null
1282 * set extra null
1283 * set deviceList null
1284 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1285 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1286 * deviceTypeId
1287 * @tc.type: FUNC
1288 * @tc.require: AR000GHSJK
1289 */
1290 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0)
1291 {
1292 // 1. set packName null
1293 std::string packName = "";
1294 // set extra null
1295 std::string extra = "";
1296 // set deviceList null
1297 std::vector<DmDeviceInfo> deviceList;
1298 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1299 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1300 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1301 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1302 }
1303
1304 /**
1305 * @tc.name: GetTrustedDeviceList_002
1306 * @tc.desc: 1. set packName not null
1307 * set extra null
1308 * set deviceList null
1309 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1310 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1311 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1312 * deviceTypeId
1313 * @tc.type: FUNC
1314 * @tc.require: AR000GHSJK
1315 */
1316 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0)
1317 {
1318 // 1. set packName not null
1319 std::string packName = "com.ohos.test";
1320 // set extra null
1321 std::string extra = "";
1322 // set deviceList null
1323 std::vector<DmDeviceInfo> deviceList;
1324 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1325 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1326 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1327 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1328 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1329 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1330 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1331 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1332 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1333 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1334 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1335 }
1336
1337 /**
1338 * @tc.name: GetTrustedDeviceList_003
1339 * @tc.desc: 1. set packName not null
1340 * set extra null
1341 * set deviceList null
1342 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1343 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1344 * 4. check ret is DM_OK
1345 * deviceTypeId
1346 * @tc.type: FUNC
1347 * @tc.require: AR000GHSJK
1348 */
1349 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_003, testing::ext::TestSize.Level0)
1350 {
1351 // 1. set packName not null
1352 std::string packName = "com.ohos.test";
1353 // set extra null
1354 std::string extra = "";
1355 // set deviceList null
1356 std::vector<DmDeviceInfo> deviceList;
1357 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1358 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1359 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1360 // 3. check ret is DM_OK
1361 ASSERT_EQ(ret, DM_OK);
1362 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1363 }
1364
1365 /**
1366 * @tc.name: GetTrustedDeviceList_004
1367 * @tc.desc: 1. set packName not null
1368 * set extra null
1369 * set deviceList null
1370 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1371 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1372 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1373 * deviceTypeId
1374 * @tc.type: FUNC
1375 * @tc.require: AR000GHSJK
1376 */
1377 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_004, testing::ext::TestSize.Level0)
1378 {
1379 // 1. set packName not null
1380 std::string packName = "com.ohos.test";
1381 // set extra null
1382 std::string extra = "test";
1383 // set deviceList null
1384 std::vector<DmDeviceInfo> deviceList;
1385 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1386 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1387 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1388 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1389 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1390 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1391 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1392 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1393 // 3. check ret is DEVICEMANAGER_IPC_FAILED
1394 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1395 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1396 }
1397
1398 /**
1399 * @tc.name: GetTrustedDeviceList_005
1400 * @tc.desc: 1. set packName null
1401 * set extra null
1402 * set deviceList null
1403 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1404 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1405 * deviceTypeId
1406 * @tc.type: FUNC
1407 * @tc.require: AR000GHSJK
1408 */
1409 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_005, testing::ext::TestSize.Level0)
1410 {
1411 // 1. set packName null
1412 std::string packName = "";
1413 // set extra null
1414 std::string extra = "test";
1415 // set deviceList null
1416 std::vector<DmDeviceInfo> deviceList;
1417 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1418 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1419 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1420 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1421 }
1422
1423 /**
1424 * @tc.name: GetTrustedDeviceList_006
1425 * @tc.desc: 1. set packName null
1426 * set extra null
1427 * set deviceList null
1428 * set isRefresh true
1429 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1430 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1431 * deviceTypeId
1432 * @tc.type: FUNC
1433 */
1434 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_006, testing::ext::TestSize.Level0)
1435 {
1436 std::string packName = "";
1437 std::string extra = "";
1438 bool isRefresh = true;
1439 std::vector<DmDeviceInfo> deviceList;
1440 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, isRefresh, deviceList);
1441 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1442 }
1443
1444 /**
1445 * @tc.name: GetTrustedDeviceList_007
1446 * @tc.desc: 1. set packName not null
1447 * set extra null
1448 * set deviceList null
1449 * set isRefresh true
1450 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1451 * 3. check ret is DM_OK
1452 * deviceTypeId
1453 * @tc.type: FUNC
1454 */
1455 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_007, testing::ext::TestSize.Level0)
1456 {
1457 std::string packName = "com.ohos.test";
1458 std::string extra = "";
1459 bool isRefresh = true;
1460 std::vector<DmDeviceInfo> deviceList;
1461 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, isRefresh, deviceList);
1462 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1463 }
1464
1465 /**
1466 * @tc.name: GetLocalDeviceInfo_001
1467 * @tc.desc: 1. set packName null
1468 * set extra null
1469 * set deviceList null
1470 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1471 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1472 * deviceTypeId
1473 * @tc.type: FUNC
1474 * @tc.require: AR000GHSJK
1475 */
1476 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0)
1477 {
1478 // 1. set packName not null
1479 std::string packName = "com.ohos.test";
1480 DmDeviceInfo info;
1481 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1482 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1483 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1484 ASSERT_EQ(ret, DM_OK);
1485 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1486 }
1487
1488 /**
1489 * @tc.name: GetLocalDeviceInfo_002
1490 * @tc.desc: 1. set packName not null
1491 * set extra null
1492 * set deviceList null
1493 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1494 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1495 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1496 * deviceTypeId
1497 * @tc.type: FUNC
1498 * @tc.require: AR000GHSJK
1499 */
1500 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_002, testing::ext::TestSize.Level0)
1501 {
1502 // 1. set packName not null
1503 std::string packName = "com.ohos.test";
1504 // set extra null
1505 DmDeviceInfo info;
1506 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1507 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1508 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1509 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1510 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1511 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1512 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1513 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1514 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1515 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1516 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1517 }
1518
1519 /**
1520 * @tc.name: GetLocalDeviceInfo_003
1521 * @tc.desc: 1. set packName not null
1522 * set extra null
1523 * set deviceList null
1524 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1525 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1526 * 4. check ret is DM_OK
1527 * deviceTypeId
1528 * @tc.type: FUNC
1529 * @tc.require: AR000GHSJK
1530 */
1531 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_003, testing::ext::TestSize.Level0)
1532 {
1533 // 1. set packName not null
1534 std::string packName = "com.ohos.test";
1535 // set extra null
1536 DmDeviceInfo info;
1537 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1538 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1539 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1540 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1541 // 3. check ret is DM_OK
1542 ASSERT_EQ(ret, DM_OK);
1543 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1544 }
1545
1546 /**
1547 * @tc.name: GetLocalDeviceInfo_004
1548 * @tc.desc: 1. set packName not null
1549 * set extra null
1550 * set deviceList null
1551 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1552 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1553 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1554 * deviceTypeId
1555 * @tc.type: FUNC
1556 * @tc.require: AR000GHSJK
1557 */
1558 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_004, testing::ext::TestSize.Level0)
1559 {
1560 // 1. set packName not null
1561 std::string packName = "com.ohos.test";
1562 // set extra null
1563 DmDeviceInfo info;
1564 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1565 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1566 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1567 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1568 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1569 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1570 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1571 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1572 // 3. check ret is DEVICEMANAGER_IPC_FAILED
1573 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1574 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1575 }
1576
1577 /**
1578 * @tc.name: GetLocalDeviceInfo_005
1579 * @tc.desc: 1. set packName null
1580 * set extra null
1581 * set deviceList null
1582 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1583 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1584 * deviceTypeId
1585 * @tc.type: FUNC
1586 * @tc.require: AR000GHSJK
1587 */
1588 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_005, testing::ext::TestSize.Level0)
1589 {
1590 // 1. set packName not null
1591 std::string packName = "";
1592 // set extra null
1593 DmDeviceInfo info;
1594 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1595 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1596 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1597 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1598 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1599 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1600 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1601 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1602 // 3. check ret is DEVICEMANAGER_IPC_FAILED
1603 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1604 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1605 }
1606
1607 /**
1608 * @tc.name: RegisterDevStateCallback_001
1609 * @tc.desc: 1. set packName null
1610 * set extra null
1611 * set callback null
1612 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1613 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
1614 * deviceTypeId
1615 * @tc.type: FUNC
1616 * @tc.require: AR000GHSJK
1617 */
1618 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0)
1619 {
1620 // 1. set packName null
1621 std::string packName = "";
1622 // set extra null
1623 std::string extra= "";
1624 // set callback nullptr
1625 std::shared_ptr<DeviceStateCallback> callback = nullptr;
1626 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1627 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
1628 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1629 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1630 }
1631
1632 /**
1633 * @tc.name: RegisterDevStateCallback_002
1634 * @tc.desc: 1. set packName not null
1635 * set extra null
1636 * set callback not null
1637 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1638 * 3. check ret is DM_OK
1639 * deviceTypeId
1640 * @tc.type: FUNC
1641 * @tc.require: AR000GHSJK
1642 */
1643 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_002, testing::ext::TestSize.Level0)
1644 {
1645 // 1. set packName null
1646 std::string packName = "com.ohos.test";
1647 // set extra null
1648 std::string extra= "";
1649 // set callback not null
1650 std::shared_ptr<DeviceStateCallback> dsCallback =std::make_shared<DeviceStateCallbackTest>();
1651 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1652 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1653 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1654 ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, dsCallback);
1655 // 3. check ret is DM_OK
1656 ASSERT_EQ(ret, DM_OK);
1657 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1658 }
1659
1660 /**
1661 * @tc.name: RegisterDevStateCallback_003
1662 * @tc.desc: 1. set packName null
1663 * set extra not null
1664 * set callback null
1665 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1666 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1667 * deviceTypeId
1668 * @tc.type: FUNC
1669 * @tc.require: AR000GHSJK
1670 */
1671 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_003, testing::ext::TestSize.Level0)
1672 {
1673 // 1. set packName null
1674 std::string pkgName = "";
1675 // set extra null
1676 std::string extra= "test";
1677 // set callback nullptr
1678 std::shared_ptr<DeviceStateCallback> callback = nullptr;
1679 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1680 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
1681 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1682 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1683 }
1684
1685 /**
1686 * @tc.name: RegisterDevStateCallback_004
1687 * @tc.desc: 1. set packName not null
1688 * set extra not null
1689 * set callback not null
1690 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1691 * 3. check ret is DM_OK
1692 * deviceTypeId
1693 * @tc.type: FUNC
1694 * @tc.require: AR000GHSJK
1695 */
1696 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_004, testing::ext::TestSize.Level0)
1697 {
1698 // 1. set packName null
1699 std::string pkgName = "com.ohos.test";
1700 // set extra null
1701 std::string extra= "test";
1702 // set callback nullptr
1703 std::shared_ptr<DeviceStateCallback> callback = nullptr;
1704 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1705 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
1706 // 3. check ret is DM_OK
1707 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1708 }
1709
1710 /**
1711 * @tc.name: RegisterDevStateCallback_005
1712 * @tc.desc: 1. set packName not null
1713 * set extra not null
1714 * set callback null
1715 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1716 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1717 * deviceTypeId
1718 * @tc.type: FUNC
1719 * @tc.require: AR000GHSJK
1720 */
1721 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_005, testing::ext::TestSize.Level0)
1722 {
1723 // 1. set packName null
1724 std::string pkgName = "com.ohos.test";
1725 // set extra null
1726 std::string extra= "test1";
1727 // set callback nullptr
1728 std::shared_ptr<DeviceStateCallback> callback = nullptr;
1729 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1730 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
1731 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1732 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1733 }
1734
1735 /**
1736 * @tc.name: UnRegisterDevStateCallback_001
1737 * @tc.desc: 1. set packName null
1738 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1739 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1740 * deviceTypeId
1741 * @tc.type: FUNC
1742 * @tc.require: AR000GHSJK
1743 */
1744 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0)
1745 {
1746 // 1. set packName null
1747 std::string packName = "";
1748 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1749 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1750 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1751 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1752 }
1753
1754 /**
1755 * @tc.name: UnRegisterDevStateCallback_002
1756 * @tc.desc: 1. set packName null
1757 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1758 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1759 * deviceTypeId
1760 * @tc.type: FUNC
1761 * @tc.require: AR000GHSJK
1762 */
1763 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_002, testing::ext::TestSize.Level0)
1764 {
1765 // 1. set packName null
1766 std::string packName = "";
1767 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1768 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1769 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1770 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1771 }
1772
1773 /**
1774 * @tc.name: UnRegisterDevStateCallback_003
1775 * @tc.desc: 1. set packName null
1776 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1777 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1778 * deviceTypeId
1779 * @tc.type: FUNC
1780 * @tc.require: AR000GHSJK
1781 */
1782 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_003, testing::ext::TestSize.Level0)
1783 {
1784 // 1. set packName null
1785 std::string packName = "";
1786 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1787 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1788 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1789 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1790 }
1791
1792 /**
1793 * @tc.name: UnRegisterDevStateCallback_004
1794 * @tc.desc: 1. set packName null
1795 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1796 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1797 * deviceTypeId
1798 * @tc.type: FUNC
1799 * @tc.require: AR000GHSJK
1800 */
1801 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_004, testing::ext::TestSize.Level0)
1802 {
1803 // 1. set packName null
1804 std::string packName = "";
1805 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1806 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1807 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1808 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1809 }
1810
1811 /**
1812 * @tc.name: UnRegisterDevStateCallback_005
1813 * @tc.desc: 1. set packName null
1814 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1815 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1816 * deviceTypeId
1817 * @tc.type: FUNC
1818 * @tc.require: AR000GHSJK
1819 */
1820 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_005, testing::ext::TestSize.Level0)
1821 {
1822 // 1. set packName null
1823 std::string packName = "";
1824 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1825 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1826 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1827 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1828 }
1829
1830 /**
1831 * @tc.name: StartDeviceDiscovery_001
1832 * @tc.desc: 1. set packName null
1833 * set subscribeInfo null
1834 * set callback null
1835 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1836 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1837 * deviceTypeId
1838 * @tc.type: FUNC
1839 * @tc.require: AR000GHSJK
1840 */
1841 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
1842 {
1843 // 1. set packName null
1844 std::string packName = "";
1845 // set subscribeInfo null
1846 std::string extra = "test";
1847 DmSubscribeInfo subscribeInfo;
1848 // set callback null
1849 std::shared_ptr<DiscoveryCallback> callback = nullptr;
1850 // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1851 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1852 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1853 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1854 }
1855
1856 /**
1857 * @tc.name: StartDeviceDiscovery_002
1858 * @tc.desc: 1. set packName null
1859 * set subscribeInfo null
1860 * set callback null
1861 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1862 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1863 * deviceTypeId
1864 * @tc.type: FUNC
1865 * @tc.require: AR000GHSJK
1866 */
1867 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
1868 {
1869 // 1. set packName null
1870 std::string packName = "com.ohos.helloworld";
1871 std::string extra = "test";
1872 // set subscribeInfo null
1873 DmSubscribeInfo subscribeInfo;
1874 // set callback null
1875 std::shared_ptr<DiscoveryCallback> callback = nullptr;
1876 // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1877 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1878 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1879 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1880 }
1881
1882 /**
1883 * @tc.name: StartDeviceDiscovery_003
1884 * @tc.desc: 1. set packName null
1885 * set subscribeInfo null
1886 * set callback null
1887 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1888 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
1889 * deviceTypeId
1890 * @tc.type: FUNC
1891 * @tc.require: AR000GHSJK
1892 */
1893 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0)
1894 {
1895 // 1. set packName not null
1896 std::string packName = "com.ohos.test";
1897 // set subscribeInfo is 0
1898 DmSubscribeInfo subscribeInfo;
1899 std::string extra = "test";
1900 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
1901 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1902 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1903 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1904 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1905 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1906 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1907 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1908 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1909 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1910 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1911 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1912 }
1913
1914 /**
1915 * @tc.name: StartDeviceDiscovery_004
1916 * @tc.desc: 1. set packName not null
1917 * set subscribeInfo null
1918 * set callback not null
1919 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1920 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1921 * 4. check ret is DM_OK
1922 * deviceTypeId
1923 * @tc.type: FUNC
1924 * @tc.require: AR000GHSJK
1925 */
1926 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0)
1927 {
1928 // 1. set packName not null
1929 std::string packName = "com.ohos.helloworld";
1930 std::string extra= "test";
1931 // set subscribeInfo null
1932 DmSubscribeInfo subscribeInfo;
1933 // set callback not null
1934 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
1935 // 2. MOCK IpcClientProxy SendRequest return DM_OK
1936 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1937 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1938 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1939 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1940 .Times(1).WillOnce(testing::Return(DM_OK));
1941 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1942 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1943 // 4. check ret is DM_OK
1944 ASSERT_EQ(ret, DM_OK);
1945 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1946 }
1947
1948 /**
1949 * @tc.name: StartDeviceDiscovery_005
1950 * @tc.desc: 1. set packName not null
1951 * set subscribeInfo null
1952 * set callback not null
1953 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1954 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1955 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1956 * deviceTypeId
1957 * @tc.type: FUNC
1958 * @tc.require: AR000GHSJK
1959 */
1960 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_005, testing::ext::TestSize.Level0)
1961 {
1962 // 1. set packName not null
1963 std::string packName = "com.ohos.helloworld";
1964 std::string extra= "test";
1965 // set subscribeInfo null
1966 DmSubscribeInfo subscribeInfo;
1967 // set callback not null
1968 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
1969 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1970 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1971 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1972 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1973 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1974 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1975 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1976 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1977 // 4. check ret is DEVICEMANAGER_IPC_FAILED
1978 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1979 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1980 }
1981
1982 /**
1983 * @tc.name: StopDeviceDiscovery_001
1984 * @tc.desc: 1. set packName null
1985 * set subscribeId is 0
1986 * 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1987 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1988 * deviceTypeId
1989 * @tc.type: FUNC
1990 * @tc.require: AR000GHSJK
1991 */
1992 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0)
1993 {
1994 // 1. set packName null
1995 std::string packName = "";
1996 // set subscribeInfo is 0
1997 uint16_t subscribeId = 0;
1998 // 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1999 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
2000 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2001 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2002 }
2003
2004 /**
2005 * @tc.name: StopDeviceDiscovery_002
2006 * @tc.desc: 1. set packName not null
2007 * set subscribeId is 0
2008 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2009 * 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2010 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2011 * deviceTypeId
2012 * @tc.type: FUNC
2013 * @tc.require: AR000GHSJK
2014 */
2015 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0)
2016 {
2017 // 1. set packName not null
2018 std::string packName = "com.ohos.test";
2019 // set subscribeInfo is 0
2020 uint16_t subscribeId = 0;
2021 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2022 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2023 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2024 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2025 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2026 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2027 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2028 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
2029 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2030 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2031 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2032 }
2033
2034 /**
2035 * @tc.name: StopDeviceDiscovery_003
2036 * @tc.desc: 1. set packName not null
2037 * set subscribeId is 0
2038 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2039 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2040 * 4. check ret is DM_OK
2041 * deviceTypeId
2042 * @tc.type: FUNC
2043 * @tc.require: AR000GHSJK
2044 */
2045 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_003, testing::ext::TestSize.Level0)
2046 {
2047 // 1. set packName not null
2048 std::string packName = "com.ohos.test";
2049 // set subscribeInfo is 0
2050 uint16_t subscribeId = 0;
2051 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2052 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2053 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2054 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2055 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2056 .Times(1).WillOnce(testing::Return(DM_OK));
2057 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
2058 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2059 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
2060 // 4. check ret is DM_OK
2061 ASSERT_EQ(ret, DM_OK);
2062 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2063 }
2064
2065 /**
2066 * @tc.name: StopDeviceDiscovery_004
2067 * @tc.desc: 1. set packName not null
2068 * set subscribeId is 0
2069 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2070 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2071 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2072 * deviceTypeId
2073 * @tc.type: FUNC
2074 * @tc.require: AR000GHSJK
2075 */
2076 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_004, testing::ext::TestSize.Level0)
2077 {
2078 // 1. set packName not null
2079 std::string packName = "com.ohos.test";
2080 // set subscribeInfo is 0
2081 uint16_t subscribeId = 0;
2082 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2083 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2084 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2085 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2086 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2087 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2088 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2089 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
2090 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2091 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2092 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2093 }
2094
2095 /**
2096 * @tc.name: StopDeviceDiscovery_005
2097 * @tc.desc: 1. set packName not null
2098 * set subscribeId is 0
2099 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2100 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2101 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2102 * deviceTypeId
2103 * @tc.type: FUNC
2104 * @tc.require: AR000GHSJK
2105 */
2106 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_005, testing::ext::TestSize.Level0)
2107 {
2108 // 1. set packName not null
2109 std::string packName = "com.ohos.test";
2110 // set subscribeInfo is 0
2111 uint16_t subscribeId = 0;
2112 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2113 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2114 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2115 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2116 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2117 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2118 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2119 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
2120 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2121 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2122 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2123 }
2124
2125 /**
2126 * @tc.name: PublishDeviceDiscovery_001
2127 * @tc.desc: 1. set packName null
2128 * set subscribeInfo null
2129 * set callback null
2130 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2131 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2132 * deviceTypeId
2133 * @tc.type: FUNC
2134 * @tc.require: I5N1K3
2135 */
2136 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
2137 {
2138 // 1. set packName null
2139 std::string packName = "";
2140 // set publishInfo null
2141 DmPublishInfo publishInfo;
2142 // set callback null
2143 std::shared_ptr<PublishCallback> callback = nullptr;
2144 // 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2145 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
2146 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2147 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2148 }
2149
2150 /**
2151 * @tc.name: PublishDeviceDiscovery_002
2152 * @tc.desc: 1. set packName null
2153 * set subscribeInfo null
2154 * set callback null
2155 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2156 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2157 * deviceTypeId
2158 * @tc.type: FUNC
2159 * @tc.require: I5N1K3
2160 */
2161 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
2162 {
2163 // 1. set packName null
2164 std::string packName = "com.ohos.helloworld";
2165 // set publishInfo null
2166 DmPublishInfo publishInfo;
2167 // set callback null
2168 std::shared_ptr<PublishCallback> callback = nullptr;
2169 // 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2170 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
2171 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2172 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2173 }
2174
2175 /**
2176 * @tc.name: PublishDeviceDiscovery_003
2177 * @tc.desc: 1. set packName null
2178 * set publishInfo null
2179 * set callback null
2180 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2181 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
2182 * deviceTypeId
2183 * @tc.type: FUNC
2184 * @tc.require: I5N1K3
2185 */
2186 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
2187 {
2188 // 1. set packName not null
2189 std::string packName = "com.ohos.test";
2190 // set publishInfo is 0
2191 DmPublishInfo publishInfo;
2192 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
2193 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2194 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2195 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2196 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2197 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2198 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2199 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2200 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
2201 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2202 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2203 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2204 }
2205
2206 /**
2207 * @tc.name: PublishDeviceDiscovery_004
2208 * @tc.desc: 1. set packName not null
2209 * set publishInfo null
2210 * set callback not null
2211 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2212 * 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2213 * 4. check ret is DM_OK
2214 * deviceTypeId
2215 * @tc.type: FUNC
2216 * @tc.require: I5N1K3
2217 */
2218 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_004, testing::ext::TestSize.Level0)
2219 {
2220 // 1. set packName not null
2221 std::string packName = "com.ohos.helloworld";
2222 // set publishInfo null
2223 DmPublishInfo publishInfo;
2224 // set callback not null
2225 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
2226 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2227 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2228 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2229 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2230 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2231 .Times(1).WillOnce(testing::Return(DM_OK));
2232 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2233 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
2234 // 4. check ret is DM_OK
2235 ASSERT_EQ(ret, DM_OK);
2236 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2237 }
2238
2239 /**
2240 * @tc.name:PublishDeviceDiscovery_005
2241 * @tc.desc: 1. set packName not null
2242 * set subscribeInfo null
2243 * set callback not null
2244 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2245 * 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2246 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2247 * deviceTypeId
2248 * @tc.type: FUNC
2249 * @tc.require: I5N1K3
2250 */
2251 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_005, testing::ext::TestSize.Level0)
2252 {
2253 // 1. set packName not null
2254 std::string packName = "com.ohos.helloworld";
2255 // set publishInfo null
2256 DmPublishInfo publishInfo;
2257 // set callback not null
2258 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
2259 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2260 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2261 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2262 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2263 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2264 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2265 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
2266 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
2267 // 4. check ret is DEVICEMANAGER_IPC_FAILED
2268 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2269 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2270 }
2271
2272 /**
2273 * @tc.name: UnPublishDeviceDiscovery_001
2274 * @tc.desc: 1. set packName null
2275 * set publishId is 0
2276 * 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2277 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2278 * deviceTypeId
2279 * @tc.type: FUNC
2280 * @tc.require: I5N1K3
2281 */
2282 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
2283 {
2284 // 1. set packName null
2285 std::string packName = "";
2286 // set publishId is 0
2287 int32_t publishId = 0;
2288 // 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2289 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
2290 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2291 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2292 }
2293
2294 /**
2295 * @tc.name: UnPublishDeviceDiscovery_002
2296 * @tc.desc: 1. set packName not null
2297 * set publishId is 0
2298 * 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2299 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2300 * deviceTypeId
2301 * @tc.type: FUNC
2302 * @tc.require: I5N1K3
2303 */
2304 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
2305 {
2306 // 1. set packName not null
2307 std::string packName = "com.ohos.test";
2308 // set subscribeInfo is 0
2309 int32_t publishId = 0;
2310 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2311 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2312 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2313 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2314 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2315 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2316 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2317 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
2318 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2319 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2320 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2321 }
2322
2323 /**
2324 * @tc.name: UnPublishDeviceDiscovery_003
2325 * @tc.desc: 1. set packName not null
2326 * set publishId is 0
2327 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2328 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2329 * 4. check ret is DM_OK
2330 * deviceTypeId
2331 * @tc.type: FUNC
2332 * @tc.require: I5N1K3
2333 */
2334 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
2335 {
2336 // 1. set packName not null
2337 std::string packName = "com.ohos.test";
2338 // set subscribeInfo is 0
2339 int32_t publishId = 0;
2340 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2341 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2342 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2343 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2344 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2345 .Times(1).WillOnce(testing::Return(DM_OK));
2346 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2347 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
2348 // 4. check ret is DM_OK
2349 ASSERT_EQ(ret, DM_OK);
2350 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2351 }
2352
2353 /**
2354 * @tc.name: UnPublishDeviceDiscovery_004
2355 * @tc.desc: 1. set packName not null
2356 * set publishId is 0
2357 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2358 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2359 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2360 * deviceTypeId
2361 * @tc.type: FUNC
2362 * @tc.require: I5N1K3
2363 */
2364 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_004, testing::ext::TestSize.Level0)
2365 {
2366 // 1. set packName not null
2367 std::string packName = "com.ohos.test";
2368 // set publishId is 0
2369 int32_t publishId = 0;
2370 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2371 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2372 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2373 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2374 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2375 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2376 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2377 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
2378 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2379 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2380 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2381 }
2382
2383 /**
2384 * @tc.name: UnPublishDeviceDiscovery_005
2385 * @tc.desc: 1. set packName not null
2386 * set publishId is 0
2387 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2388 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
2389 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2390 * deviceTypeId
2391 * @tc.type: FUNC
2392 * @tc.require: I5N1K3
2393 */
2394 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_005, testing::ext::TestSize.Level0)
2395 {
2396 // 1. set packName not null
2397 std::string packName = "com.ohos.test";
2398 // set publishId is 0
2399 int32_t publishId = 0;
2400 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2401 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2402 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2403 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2404 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2405 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2406 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2407 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
2408 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2409 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2410 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2411 }
2412
2413 /**
2414 * @tc.name: AuthenticateDevice_001
2415 * @tc.desc: 1. set packName = null
2416 * set dmDeviceInfo = null
2417 * set dmAppImageInfo = null
2418 * set extra = null
2419 * set callback = nullptr
2420 * 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2421 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
2422 * deviceTypeId
2423 * @tc.type: FUNC
2424 * @tc.require: AR000GHSJK
2425 */
2426 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
2427 {
2428 // 1. set packName = null
2429 std::string packName = "";
2430 int32_t authType = 1;
2431 // set dmDeviceInfo = null
2432 DmDeviceInfo dmDeviceInfo;
2433 // set extra = null
2434 std::string extra= "";
2435 // set callback = nullptr
2436 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2437 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2438 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
2439 // 3. check ret is DEVICEMANAGER_INVALID_VALUE
2440 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2441 }
2442
2443 /**
2444 * @tc.name: AuthenticateDevice_002
2445 * @tc.desc: 1. set packName not null
2446 * set dmDeviceInfo null
2447 * set dmAppImageInfo null
2448 * set extra null
2449 * set callback null
2450 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2451 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2452 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2453 * deviceTypeId
2454 * @tc.type: FUNC
2455 * @tc.require: AR000GHSJK
2456 */
2457 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
2458 {
2459 // 1. set packName not null
2460 std::string packName = "com.ohos.helloworld";
2461 int32_t authType = 1;
2462 // set dmDeviceInfo null
2463 DmDeviceInfo dmDeviceInfo;
2464 // set extra null
2465 std::string extra = "";
2466 // set callback null
2467 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2468 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2469 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2470 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2471 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2472 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2473 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2474 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2475 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
2476 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2477 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2478 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2479 }
2480
2481 /**
2482 * @tc.name: AuthenticateDevice_003
2483 * @tc.desc: 1. set packName not null
2484 * set dmDeviceInfo null
2485 * set dmAppImageInfo null
2486 * set extra null
2487 * set callback null
2488 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2489 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2490 * 4. check ret is DM_OK
2491 * deviceTypeId
2492 * @tc.type: FUNC
2493 * @tc.require: AR000GHSJK
2494 */
2495 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
2496 {
2497 // 1. set packName not null
2498 std::string packName = "com.ohos.helloworld";
2499 // set dmDeviceInfo null
2500 int32_t authType = 1;
2501 // set dmAppImageInfo null
2502 DmDeviceInfo dmDeviceInfo;
2503 // set extra null
2504 std::string extra = "";
2505 // set callback null
2506 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2507 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2508 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2509 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2510 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2511 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2512 .Times(1).WillOnce(testing::Return(DM_OK));
2513 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2514 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
2515 // 4. check ret is DM_OK
2516 ASSERT_EQ(ret, DM_OK);
2517 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2518 }
2519
2520 /**
2521 * @tc.name: AuthenticateDevice_004
2522 * @tc.desc: 1. set packName not null
2523 * set dmDeviceInfo null
2524 * set dmAppImageInfo null
2525 * set extra null
2526 * set callback null
2527 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2528 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2529 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2530 * deviceTypeId
2531 * @tc.type: FUNC
2532 * @tc.require: AR000GHSJK
2533 */
2534 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_004, testing::ext::TestSize.Level0)
2535 {
2536 // 1. set packName not null
2537 std::string packName = "com.ohos.helloworld";
2538 // set dmDeviceInfo null
2539 int32_t authType = 1;
2540 // set dmAppImageInfo null
2541 DmDeviceInfo dmDeviceInfo;
2542 // set extra null
2543 std::string extra = "";
2544 // set callback null
2545 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2546 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2547 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2548 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2549 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2550 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2551 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2552 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2553 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
2554 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2555 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2556 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2557 }
2558
2559 /**
2560 * @tc.name: AuthenticateDevice_005
2561 * @tc.desc: 1. set packName not null
2562 * set dmDeviceInfo null
2563 * set dmAppImageInfo null
2564 * set extra null
2565 * set callback null
2566 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2567 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2568 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2569 * deviceTypeId
2570 * @tc.type: FUNC
2571 * @tc.require: AR000GHSJK
2572 */
2573 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_005, testing::ext::TestSize.Level0)
2574 {
2575 // 1. set packName not null
2576 std::string packName = "com.ohos.helloworld";
2577 // set dmDeviceInfo null
2578 int32_t authType = 1;
2579 // set dmAppImageInfo null
2580 DmDeviceInfo dmDeviceInfo;
2581 // set extra null
2582 std::string extra = "";
2583 // set callback null
2584 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2585 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2586 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2587 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2588 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2589 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2590 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2591 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2592 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
2593 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2594 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2595 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2596 }
2597
2598 /**
2599 * @tc.name: UnAuthenticateDevice_001
2600 * @tc.desc: 1. set packName = null
2601 * set dmDeviceInfo = null
2602 * set dmAppImageInfo = null
2603 * set extra = null
2604 * set callback = nullptr
2605 * 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2606 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
2607 * deviceTypeId
2608 * @tc.type: FUNC
2609 * @tc.require: AR000GHSJK
2610 */
2611 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
2612 {
2613 // 1. set packName = null
2614 std::string packName = "";
2615 DmDeviceInfo deviceInfo;
2616 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2617 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
2618 // 3. check ret is DEVICEMANAGER_INVALID_VALUE
2619 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2620 }
2621
2622 /**
2623 * @tc.name: UnAuthenticateDevice_002
2624 * @tc.desc: 1. set packName not null
2625 * set dmDeviceInfo null
2626 * set dmAppImageInfo null
2627 * set extra null
2628 * set callback null
2629 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2630 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2631 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2632 * deviceTypeId
2633 * @tc.type: FUNC
2634 * @tc.require: AR000GHSJK
2635 */
2636 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
2637 {
2638 // 1. set packName = null
2639 std::string packName = "com.ohos.helloworld";
2640 DmDeviceInfo deviceInfo;
2641 deviceInfo.deviceId[0] = '\0';
2642 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2643 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
2644 // 3. check ret is DEVICEMANAGER_INVALID_VALUE
2645 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2646 }
2647
2648 /**
2649 * @tc.name: UnAuthenticateDevice_003
2650 * @tc.desc: 1. set packName not null
2651 * set dmDeviceInfo null
2652 * set dmAppImageInfo null
2653 * set extra null
2654 * set callback null
2655 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2656 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2657 * 4. check ret is DM_OK
2658 * deviceTypeId
2659 * @tc.type: FUNC
2660 * @tc.require: AR000GHSJK
2661 */
2662 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
2663 {
2664 // 1. set packName not null
2665 std::string packName = "com.ohos.helloworld";
2666 DmDeviceInfo deviceInfo;
2667 deviceInfo.networkId[0] = '1';
2668 deviceInfo.networkId[1] = '2';
2669 deviceInfo.networkId[2] = '\0';
2670 // set callback null
2671 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2672 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2673 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2674 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2675 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2676 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2677 .Times(1).WillOnce(testing::Return(DM_OK));
2678 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2679 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
2680 // 4. check ret is DM_OK
2681 ASSERT_EQ(ret, DM_OK);
2682 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2683 }
2684
2685 /**
2686 * @tc.name: UnAuthenticateDevice_004
2687 * @tc.desc: 1. set packName not null
2688 * set dmDeviceInfo null
2689 * set dmAppImageInfo null
2690 * set extra null
2691 * set callback null
2692 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2693 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2694 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2695 * deviceTypeId
2696 * @tc.type: FUNC
2697 * @tc.require: AR000GHSJK
2698 */
2699 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0)
2700 {
2701 // 1. set packName not null
2702 std::string packName = "com.ohos.helloworld";
2703 // set dmDeviceInfo null
2704 DmDeviceInfo deviceInfo;
2705 deviceInfo.networkId[0] = '1';
2706 deviceInfo.networkId[1] = '2';
2707 deviceInfo.networkId[2] = '\0';
2708 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2709 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2710 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2711 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2712 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2713 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2714 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2715 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2716 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
2717 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2718 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2719 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2720 }
2721
2722 /**
2723 * @tc.name: UnAuthenticateDevice_005
2724 * @tc.desc: 1. set packName not null
2725 * set dmDeviceInfo null
2726 * set dmAppImageInfo null
2727 * set extra null
2728 * set callback null
2729 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2730 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2731 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2732 * deviceTypeId
2733 * @tc.type: FUNC
2734 * @tc.require: AR000GHSJK
2735 */
2736 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_005, testing::ext::TestSize.Level0)
2737 {
2738 // 1. set packName not null
2739 std::string packName = "com.ohos.helloworld";
2740 // set dmDeviceInfo null
2741 DmDeviceInfo deviceInfo;
2742 deviceInfo.networkId[0] = '1';
2743 deviceInfo.networkId[1] = '2';
2744 deviceInfo.networkId[2] = '\0';
2745 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2746 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2747 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2748 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2749 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2750 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2751 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2752 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2753 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
2754 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2755 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2756 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2757 }
2758
2759 /**
2760 * @tc.name: GetFaParam_001
2761 * @tc.desc: 1. set packName = null
2762 * set dmDeviceInfo = null
2763 * set dmAppImageInfo = null
2764 * set extra = null
2765 * set callback = nullptr
2766 * 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2767 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2768 * deviceTypeId
2769 * @tc.type: FUNC
2770 * @tc.require: AR000GHSJK
2771 */
2772 HWTEST_F(DeviceManagerImplTest, GetFaParam_001, testing::ext::TestSize.Level0)
2773 {
2774 // 1. set packName = null
2775 std::string packName = "";
2776 DmAuthParam dmFaParam;
2777 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2778 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2779 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2780 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2781 }
2782
2783 /**
2784 * @tc.name: GetFaParam_002
2785 * @tc.desc: 1. set packName not null
2786 * set dmDeviceInfo null
2787 * set dmAppImageInfo null
2788 * set extra null
2789 * set callback null
2790 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2791 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2792 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2793 * deviceTypeId
2794 * @tc.type: FUNC
2795 * @tc.require: AR000GHSJK
2796 */
2797 HWTEST_F(DeviceManagerImplTest, GetFaParam_002, testing::ext::TestSize.Level0)
2798 {
2799 // 1. set packName not null
2800 std::string packName = "com.ohos.helloworld";
2801 // set callback null
2802 DmAuthParam dmFaParam;
2803 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2804 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2805 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2806 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2807 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2808 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2809 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2810 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2811 // 4. check ret is DM_OK
2812 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2813 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2814 }
2815
2816 /**
2817 * @tc.name: GetFaParam_003
2818 * @tc.desc: 1. set packName not null
2819 * set dmDeviceInfo null
2820 * set dmAppImageInfo null
2821 * set extra null
2822 * set callback null
2823 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2824 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2825 * 4. check ret is DM_OK
2826 * deviceTypeId
2827 * @tc.type: FUNC
2828 * @tc.require: AR000GHSJK
2829 */
2830 HWTEST_F(DeviceManagerImplTest, GetFaParam_003, testing::ext::TestSize.Level0)
2831 {
2832 // 1. set packName not null
2833 std::string packName = "com.ohos.helloworld";
2834 // set callback null
2835 DmAuthParam dmFaParam;
2836 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2837 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
2838 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
2839 // 3. call DeviceManagerImpl::GetFaParam with parameter
2840 ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2841 // 4. check ret is DM_OK
2842 ASSERT_EQ(ret, DM_OK);
2843 DeviceManager::GetInstance().UnInitDeviceManager(packName);
2844 }
2845
2846 /**
2847 * @tc.name: GetFaParam_004
2848 * @tc.desc: 1. set packName not null
2849 * set dmDeviceInfo null
2850 * set dmAppImageInfo null
2851 * set extra null
2852 * set callback null
2853 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2854 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2855 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2856 * deviceTypeId
2857 * @tc.type: FUNC
2858 * @tc.require: AR000GHSJK
2859 */
2860 HWTEST_F(DeviceManagerImplTest, GetFaParam_004, testing::ext::TestSize.Level0)
2861 {
2862 // 1. set packName not null
2863 std::string packName = "com.ohos.helloworld";
2864 // set dmDeviceInfo null
2865 DmAuthParam dmFaParam;
2866 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2867 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2868 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2869 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2870 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2871 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2872 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2873 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2874 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2875 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2876 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2877 }
2878
2879 /**
2880 * @tc.name: GetFaParam_005
2881 * @tc.desc: 1. set packName not null
2882 * set dmDeviceInfo null
2883 * set dmAppImageInfo null
2884 * set extra null
2885 * set callback null
2886 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2887 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2888 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2889 * deviceTypeId
2890 * @tc.type: FUNC
2891 * @tc.require: AR000GHSJK
2892 */
2893 HWTEST_F(DeviceManagerImplTest, GetFaParam_005, testing::ext::TestSize.Level0)
2894 {
2895 // 1. set packName not null
2896 std::string packName = "com.ohos.helloworld";
2897 // set dmDeviceInfo null
2898 DmAuthParam dmFaParam;
2899 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2900 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2901 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2902 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2903 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2904 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2905 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2906 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2907 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2908 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2909 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2910 }
2911
2912 /**
2913 * @tc.name: SetUserOperation_001
2914 * @tc.desc: 1. set packName null
2915 * set action null
2916 * 2. call DeviceManagerImpl::SetUserOperation with parameter
2917 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2918 * deviceTypeId
2919 * @tc.type: FUNC
2920 * @tc.require: AR000GHSJK
2921 */
2922 HWTEST_F(DeviceManagerImplTest, SetUserOperation_001, testing::ext::TestSize.Level0)
2923 {
2924 // 1. set packName null
2925 std::string packName = "";
2926 // set authParam null
2927 int32_t action = 0;
2928 const std::string param = "extra";
2929 // 2. call DeviceManagerImpl::SetUserOperation with parameter
2930 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
2931 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2932 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2933 }
2934
2935 /**
2936 * @tc.name: SetUserOperation_002
2937 * @tc.desc: 1. set packName not null
2938 * set action null
2939 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2940 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2941 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2942 * deviceTypeId
2943 * @tc.type: FUNC
2944 * @tc.require: AR000GHSJK
2945 */
2946 HWTEST_F(DeviceManagerImplTest, SetUserOperation_002, testing::ext::TestSize.Level0)
2947 {
2948 // 1. set packName null
2949 std::string packName = "com.ohos.test";
2950 // set authParam null
2951 int32_t action = 0;
2952 const std::string param = "extra";
2953 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2954 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2955 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2956 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2957 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2958 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2959 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2960 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
2961 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2962 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2963 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2964 }
2965
2966 /**
2967 * @tc.name: SetUserOperation_003
2968 * @tc.desc: 1. set packName not null
2969 * set action null
2970 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2971 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2972 * 4. check ret is DM_OK
2973 * deviceTypeId
2974 * @tc.type: FUNC
2975 * @tc.require: AR000GHSJK
2976 */
2977 HWTEST_F(DeviceManagerImplTest, SetUserOperation_003, testing::ext::TestSize.Level0)
2978 {
2979 // 1. set packName not null
2980 std::string packName = "com.ohos.test";
2981 // set authParam null
2982 int32_t action = 0;
2983 const std::string param = "extra";
2984 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2985 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
2986 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
2987 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2988 ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
2989 // 4. check ret is DM_OK
2990 ASSERT_EQ(ret, DM_OK);
2991 DeviceManager::GetInstance().UnInitDeviceManager(packName);
2992 }
2993
2994 /**
2995 * @tc.name: SetUserOperation_004
2996 * @tc.desc: 1. set packName not null
2997 * set action null
2998 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2999 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3000 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3001 * deviceTypeId
3002 * @tc.type: FUNC
3003 * @tc.require: AR000GHSJK
3004 */
3005 HWTEST_F(DeviceManagerImplTest, SetUserOperation_004, testing::ext::TestSize.Level0)
3006 {
3007 // 1. set packName null
3008 std::string packName = "com.ohos.test";
3009 // set authParam null
3010 int32_t action = 0;
3011 const std::string param = "extra";
3012 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3013 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3014 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3015 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3016 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3017 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3018 // 3. call DeviceManagerImpl::SetUserOperation with parameter
3019 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
3020 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3021 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3022 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3023 }
3024
3025 /**
3026 * @tc.name: SetUserOperation_005
3027 * @tc.desc: 1. set packName not null
3028 * set action null
3029 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
3030 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3031 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3032 * deviceTypeId
3033 * @tc.type: FUNC
3034 * @tc.require: AR000GHSJK
3035 */
3036 HWTEST_F(DeviceManagerImplTest, SetUserOperation_005, testing::ext::TestSize.Level0)
3037 {
3038 // 1. set packName null
3039 std::string packName = "com.ohos.test";
3040 // set authParam null
3041 int32_t action = 0;
3042 const std::string param = "extra";
3043 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
3044 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3045 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3046 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3047 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3048 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
3049 // 3. call DeviceManagerImpl::SetUserOperation with parameter
3050 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
3051 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3052 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3053 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3054 }
3055
3056 /**
3057 * @tc.name: GetUdidByNetworkId_001
3058 * @tc.desc: 1. set packName null
3059 * set action null
3060 * 2. call DeviceManagerImpl::SetUserOperation with parameter
3061 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3062 * deviceTypeId
3063 * @tc.type: FUNC
3064 * @tc.require: AR000GHSJK
3065 */
3066 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0)
3067 {
3068 // 1. set packName null
3069 std::string packName = "";
3070 // set authParam null
3071 std::string netWorkId = "111";
3072 std::string udid = "222";
3073 // 2. call DeviceManagerImpl::SetUserOperation with parameter
3074 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
3075 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3076 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3077 }
3078
3079 /**
3080 * @tc.name: GetUdidByNetworkId_002
3081 * @tc.desc: 1. set packName not null
3082 * set action null
3083 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
3084 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3085 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3086 * deviceTypeId
3087 * @tc.type: FUNC
3088 * @tc.require: AR000GHSJK
3089 */
3090 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0)
3091 {
3092 // 1. set packName null
3093 std::string packName = "com.ohos.test";
3094 // set authParam null
3095 std::string netWorkId = "111";
3096 std::string udid = "222";
3097 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
3098 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3099 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3100 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3101 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3102 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
3103 // 3. call DeviceManagerImpl::SetUserOperation with parameter
3104 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
3105 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3106 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3107 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3108 }
3109
3110 /**
3111 * @tc.name: GetUdidByNetworkId_003
3112 * @tc.desc: 1. set packName not null
3113 * set action null
3114 * 2. MOCK IpcClientProxy SendRequest return DM_OK
3115 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3116 * 4. check ret is DM_OK
3117 * deviceTypeId
3118 * @tc.type: FUNC
3119 * @tc.require: AR000GHSJK
3120 */
3121 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0)
3122 {
3123 // 1. set packName not null
3124 std::string packName = "com.ohos.test";
3125 // set authParam null
3126 std::string netWorkId = "111";
3127 std::string udid = "222";
3128 // 2. MOCK IpcClientProxy SendRequest return DM_OK
3129 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
3130 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
3131 // 3. call DeviceManagerImpl::GetUdidByNetworkId with parameter
3132 ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
3133 // 4. check ret is DM_OK
3134 ASSERT_EQ(ret, DM_OK);
3135 // DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3136 DeviceManager::GetInstance().UnInitDeviceManager(packName);
3137 }
3138
3139 /**
3140 * @tc.name: GetUdidByNetworkId_004
3141 * @tc.desc: 1. set packName not null
3142 * set action null
3143 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3144 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3145 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3146 * deviceTypeId
3147 * @tc.type: FUNC
3148 * @tc.require: AR000GHSJK
3149 */
3150 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_004, testing::ext::TestSize.Level0)
3151 {
3152 // 1. set packName null
3153 std::string packName = "com.ohos.test";
3154 // set authParam null
3155 std::string netWorkId = "111";
3156 std::string udid = "222";
3157 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3158 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3159 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3160 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3161 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3162 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3163 // 3. call DeviceManagerImpl::SetUserOperation with parameter
3164 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
3165 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3166 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3167 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3168 }
3169
3170 /**
3171 * @tc.name: GetUdidByNetworkId_005
3172 * @tc.desc: 1. set packName not null
3173 * set action null
3174 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
3175 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3176 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3177 * deviceTypeId
3178 * @tc.type: FUNC
3179 * @tc.require: AR000GHSJK
3180 */
3181 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_005, testing::ext::TestSize.Level0)
3182 {
3183 // 1. set packName null
3184 std::string packName = "com.ohos.test";
3185 // set authParam null
3186 std::string netWorkId = "111";
3187 std::string udid = "222";
3188 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
3189 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3190 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3191 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3192 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3193 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
3194 // 3. call DeviceManagerImpl::SetUserOperation with parameter
3195 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
3196 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3197 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3198 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3199 }
3200
3201 /**
3202 * @tc.name: GetUuidByNetworkId_001
3203 * @tc.desc: 1. set packName null
3204 * set action null
3205 * 2. call DeviceManagerImpl::SetUserOperation with parameter
3206 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3207 * deviceTypeId
3208 * @tc.type: FUNC
3209 * @tc.require: AR000GHSJK
3210 */
3211 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)
3212 {
3213 // 1. set packName null
3214 std::string packName = "";
3215 // set authParam null
3216 std::string netWorkId = "111";
3217 std::string uuid = "222";
3218 // 2. call DeviceManagerImpl::SetUserOperation with parameter
3219 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
3220 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3221 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3222 }
3223
3224 /**
3225 * @tc.name: GetUuidByNetworkId_002
3226 * @tc.desc: 1. set packName not null
3227 * set action null
3228 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
3229 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3230 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3231 * deviceTypeId
3232 * @tc.type: FUNC
3233 * @tc.require: AR000GHSJK
3234 */
3235 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0)
3236 {
3237 // 1. set packName null
3238 std::string packName = "com.ohos.test";
3239 // set authParam null
3240 std::string netWorkId = "111";
3241 std::string uuid = "222";
3242 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
3243 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3244 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3245 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3246 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3247 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
3248 // 3. call DeviceManagerImpl::SetUserOperation with parameter
3249 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
3250 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3251 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3252 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3253 }
3254
3255 /**
3256 * @tc.name: GetUuidByNetworkId_003
3257 * @tc.desc: 1. set packName not null
3258 * set action null
3259 * 2. MOCK IpcClientProxy SendRequest return DM_OK
3260 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3261 * 4. check ret is DM_OK
3262 * deviceTypeId
3263 * @tc.type: FUNC
3264 * @tc.require: AR000GHSJK
3265 */
3266 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0)
3267 {
3268 // 1. set packName not null
3269 std::string packName = "com.ohos.test";
3270 // set authParam null
3271 std::string netWorkId = "111";
3272 std::string uuid = "222";
3273 // 2. MOCK IpcClientProxy SendRequest return DM_OK
3274 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
3275 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
3276 // 3. call DeviceManagerImpl::GetUuidByNetworkId with parameter
3277 ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
3278 // 4. check ret is DM_OK
3279 ASSERT_EQ(ret, DM_OK);
3280 DeviceManager::GetInstance().UnInitDeviceManager(packName);
3281 }
3282
3283 /**
3284 * @tc.name: GetUuidByNetworkId_004
3285 * @tc.desc: 1. set packName not null
3286 * set action null
3287 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3288 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3289 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3290 * deviceTypeId
3291 * @tc.type: FUNC
3292 * @tc.require: AR000GHSJK
3293 */
3294 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_004, testing::ext::TestSize.Level0)
3295 {
3296 // 1. set packName null
3297 std::string packName = "com.ohos.test";
3298 // set authParam null
3299 std::string netWorkId = "111";
3300 std::string uuid = "222";
3301 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3302 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3303 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3304 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3305 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3306 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3307 // 3. call DeviceManagerImpl::SetUserOperation with parameter
3308 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
3309 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3310 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3311 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3312 }
3313
3314 /**
3315 * @tc.name: GetUuidByNetworkId_005
3316 * @tc.desc: 1. set packName not null
3317 * set action null
3318 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
3319 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3320 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3321 * deviceTypeId
3322 * @tc.type: FUNC
3323 * @tc.require: AR000GHSJK
3324 */
3325 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_005, testing::ext::TestSize.Level0)
3326 {
3327 // 1. set packName null
3328 std::string packName = "com.ohos.test";
3329 // set authParam null
3330 std::string netWorkId = "111";
3331 std::string uuid = "222";
3332 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
3333 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3334 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3335 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3336 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3337 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
3338 // 3. call DeviceManagerImpl::SetUserOperation with parameter
3339 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
3340 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3341 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3342 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3343 }
3344
3345 /**
3346 * @tc.name: RegisterDeviceManagerFaCallback_001
3347 * @tc.desc: 1. set packName not null
3348 * set action null
3349 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
3350 * 3. call DeviceManagerImpl::SetUserOperation with parameter
3351 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
3352 * deviceTypeId
3353 * @tc.type: FUNC
3354 * @tc.require: AR000GHSJK
3355 */
3356 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)
3357 {
3358 // 1. set packName null
3359 std::string packName = "";
3360 // set callback null
3361 std::shared_ptr<DeviceManagerUiCallback> callback = nullptr;
3362 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3363 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
3364 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3365 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3366 }
3367
3368 /**
3369 * @tc.name: RegisterDeviceManagerFaCallback_002
3370 * @tc.desc: 1. set packName not null
3371 * set callback not null
3372 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3373 * 3. check ret is DM_OK
3374 * deviceTypeId
3375 * @tc.type: FUNC
3376 * @tc.require: AR000GHSJK
3377 */
3378 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)
3379 {
3380 // 1. set packName null
3381 std::string packName = "com.ohos.test";
3382 // set callback null
3383 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
3384 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3385 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3386 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3387 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3388 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3389 .Times(2).WillOnce(testing::Return(DM_OK));
3390 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
3391 // 3. check ret is DM_OK
3392 ASSERT_EQ(ret, DM_OK);
3393 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3394 }
3395
3396 /**
3397 * @tc.name: RegisterDeviceManagerFaCallback_003
3398 * @tc.desc: 1. set packName not null
3399 * set callback not null
3400 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3401 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3402 * deviceTypeId
3403 * @tc.type: FUNC
3404 * @tc.require: AR000GHSJK
3405 */
3406 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)
3407 {
3408 // 1. set packName null
3409 std::string packName = "com.ohos.test";
3410 // set callback null
3411 std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr;
3412 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3413 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
3414 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3415 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3416 }
3417
3418 /**
3419 * @tc.name: RegisterDeviceManagerFaCallback_004
3420 * @tc.desc: 1. set packName not null
3421 * set callback not null
3422 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3423 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3424 * deviceTypeId
3425 * @tc.type: FUNC
3426 * @tc.require: AR000GHSJK
3427 */
3428 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)
3429 {
3430 // 1. set packName null
3431 std::string packName = "";
3432 // set callback null
3433 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
3434 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3435 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
3436 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3437 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3438 }
3439
3440 /**
3441 * @tc.name: RegisterDeviceManagerFaCallback_005
3442 * @tc.desc: 1. set packName not null
3443 * set callback not null
3444 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3445 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3446 * deviceTypeId
3447 * @tc.type: FUNC
3448 * @tc.require: AR000GHSJK
3449 */
3450 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)
3451 {
3452 // 1. set packName null
3453 std::string packName ("");
3454 // set callback null
3455 std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr;
3456 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3457 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
3458 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3459 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3460 }
3461
3462 /**
3463 * @tc.name: UnRegisterDeviceManagerFaCallback_001
3464 * @tc.desc: 1. set packName null
3465 * 2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter
3466 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3467 * deviceTypeId
3468 * @tc.type: FUNC
3469 * @tc.require: AR000GHSJK
3470 */
3471 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)
3472 {
3473 // 1. set packName null
3474 std::string packName = "";
3475 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3476 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName);
3477 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3478 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3479 }
3480
3481 /**
3482 * @tc.name: UnRegisterDeviceManagerFaCallback_002
3483 * @tc.desc: 1. set packName not null
3484 * 2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter
3485 * 3. check ret is DM_OK
3486 * deviceTypeId
3487 * @tc.type: FUNC
3488 * @tc.require: AR000GHSJK
3489 */
3490 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)
3491 {
3492 // 1. set packName null
3493 std::string packName = "com.ohos.test";
3494 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
3495 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3496 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3497 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3498 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3499 .Times(2).WillOnce(testing::Return(DM_OK));
3500 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName);
3501 // 3. check ret is DM_OK
3502 ASSERT_EQ(ret, DM_OK);
3503 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3504 }
3505
3506 /**
3507 * @tc.name: UnRegisterDeviceManagerFaCallback_003
3508 * @tc.desc: 1. set packName not null
3509 * set callback not null
3510 * 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
3511 * 3. check ret is DM_OK
3512 * 4. set checkMap null
3513 * 5. Get checkMap from DeviceManagerNotify
3514 * 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
3515 * 7. Get checkMap from pkgName
3516 * 8. check checkMap null
3517 * deviceTypeId
3518 * @tc.type: FUNC
3519 * @tc.require: AR000GHSJK
3520 */
3521 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)
3522 {
3523 // 1. set pkgName not null
3524 std::string pkgName = "com.ohos.test";
3525 // set callback not null
3526 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
3527 // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
3528 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3529 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3530 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3531 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3532 .Times(2).WillOnce(testing::Return(DM_OK));
3533 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
3534 // 3. check ret is DM_OK
3535 ASSERT_EQ(ret, DM_OK);
3536 // 4. set checkMap null
3537 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
3538 // 5. Get checkMap from DeviceManagerNotify
3539 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
3540 // 5. check checkMap not null
3541 ASSERT_NE(checkMap, nullptr);
3542 // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
3543 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3544 .Times(2).WillOnce(testing::Return(DM_OK));
3545 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(pkgName);
3546 // 7. Get checkMap from pkgName
3547 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
3548 // 8 check checkMap null
3549 ASSERT_EQ(checkMap, nullptr);
3550 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3551 }
3552
3553 /**
3554 * @tc.name: UnRegisterDeviceManagerFaCallback_004
3555 * @tc.desc: 1. set packName not null
3556 * set callback not null
3557 * 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
3558 * 3. check ret is DM_OK
3559 * 4. set checkMap null
3560 * 5. Get checkMap from DeviceManagerNotify
3561 * 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
3562 * 7. Get checkMap from pkgName
3563 * 8. check checkMap null
3564 * deviceTypeId
3565 * @tc.type: FUNC
3566 * @tc.require: AR000GHSJK
3567 */
3568 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)
3569 {
3570 // 1. set pkgName not null
3571 std::string pkgName = "com.ohos.test";
3572 // set callback not null
3573 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
3574 // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
3575 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3576 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3577 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3578 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3579 .Times(2).WillOnce(testing::Return(DM_OK));
3580 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
3581 // 3. check ret is DM_OK
3582 ASSERT_EQ(ret, DM_OK);
3583 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3584 // 4. set checkMap null
3585 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
3586 // 5. Get checkMap from DeviceManagerNotify
3587 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
3588 // 5. check checkMap not null
3589 ASSERT_NE(checkMap, nullptr);
3590 // 6. set unRegisterPkgNamr different from pkgName
3591 std::string unRegisterPkgName = "com.ohos.test1";
3592 // 7. call DeviceManager UnRegisterDeviceManagerFaCallback with unRegisterPkgName
3593 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName);
3594 // 7. Get checkMap from pkgName
3595 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
3596 // 8 check checkMap not null
3597 ASSERT_NE(checkMap, nullptr);
3598 }
3599
3600 /**
3601 * @tc.name: UnRegisterDeviceManagerFaCallback_005
3602 * @tc.desc: 1. set packName not null
3603 * 2. Set checkMap null
3604 * 3. Get checkMap from DeviceManagerNotify
3605 * 4. check checkMap not null
3606 * 5. Set unRegisterPkgName is different from register pkgName
3607 * 6. call DeviceManager UnRegisterDevStateCallback with parameter
3608 * 7. Get checkMap from DeviceManagerNotify
3609 * 8. check checkMap not null
3610 * deviceTypeId
3611 * @tc.type: FUNC
3612 * @tc.require: AR000GHSJK
3613 */
3614 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)
3615 {
3616 // 1. set pkgName not null
3617 std::string pkgName = "com.ohos.test";
3618 // 2. Set checkMap null
3619 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
3620 // 3. Get checkMap from DeviceManagerNotify
3621 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
3622 // 4. check checkMap not null
3623 ASSERT_NE(checkMap, nullptr);
3624 // 5. Set unRegisterPkgName is different from register pkgName
3625 std::string unRegisterPkgName = "com.ohos.test1";
3626 // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
3627 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName);
3628 // 7. Get checkMap from DeviceManagerNotify
3629 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
3630 // 8. check checkMap not null
3631 ASSERT_NE(checkMap, nullptr);
3632 }
3633
3634 /**
3635 * @tc.name: RegisterDevStateCallback_006
3636 * @tc.desc: 1. set packName null
3637 * set extra null
3638 * set callback null
3639 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3640 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3641 * deviceTypeId
3642 * @tc.type: FUNC
3643 * @tc.require: AR000GHSJK
3644 */
3645 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_006, testing::ext::TestSize.Level0)
3646 {
3647 // 1. set packName null
3648 std::string pkgName = "";
3649 // set extra null
3650 std::string extra= "test";
3651 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3652 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra);
3653 // 3. check ret is ERR_DM_INPUT_PARA_INVALID;
3654 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3655 }
3656
3657 /**
3658 * @tc.name: RegisterDevStateCallback_007
3659 * @tc.desc: 1. set packName not null
3660 * set extra null
3661 * set callback not null
3662 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3663 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3664 * deviceTypeId
3665 * @tc.type: FUNC
3666 * @tc.require: AR000GHSJK
3667 */
3668 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_007, testing::ext::TestSize.Level0)
3669 {
3670 // 1. set packName null
3671 std::string packName = "";
3672 // set extra null
3673 std::string extra= "";
3674 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3675 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra);
3676 // 3. check ret is DM_OK
3677 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3678 }
3679
3680 /**
3681 * @tc.name: RegisterDevStateCallback_008
3682 * @tc.desc: 1. set packName null
3683 * set extra not null
3684 * set callback null
3685 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3686 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3687 * deviceTypeId
3688 * @tc.type: FUNC
3689 * @tc.require: AR000GHSJK
3690 */
3691 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_008, testing::ext::TestSize.Level0)
3692 {
3693 // 1. set packName null
3694 std::string packName = "com.ohos.test";
3695 // set extra null
3696 std::string extra= "test";
3697 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3698 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3699 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3700 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3701 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
3702 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3703 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra);
3704 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3705 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3706 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3707 }
3708
3709 /**
3710 * @tc.name: RegisterDevStateCallback_009
3711 * @tc.desc: 1. set packName not null
3712 * set extra not null
3713 * set callback not null
3714 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3715 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3716 * deviceTypeId
3717 * @tc.type: FUNC
3718 * @tc.require: AR000GHSJK
3719 */
3720 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_009, testing::ext::TestSize.Level0)
3721 {
3722 // 1. set packName null
3723 std::string packName = "com.ohos.test";
3724 // set extra null
3725 std::string extra= "test";
3726 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3727 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3728 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3729 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3730 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3731 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3732 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra);
3733 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3734 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3735 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3736 }
3737
3738 /**
3739 * @tc.name: RegisterDevStateCallback_010
3740 * @tc.desc: 1. set packName not null
3741 * set extra not null
3742 * set callback null
3743 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3744 * 3. check ret is DM_OK
3745 * deviceTypeId
3746 * @tc.type: FUNC
3747 * @tc.require: AR000GHSJK
3748 */
3749 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_010, testing::ext::TestSize.Level0)
3750 {
3751 // 1. set packName null
3752 std::string packName = "com.ohos.test";
3753 // set extra null
3754 std::string extra= "test";
3755 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
3756 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
3757 // 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3758 ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra);
3759 // 3. check ret is DM_OK
3760 ASSERT_EQ(ret, DM_OK);
3761 DeviceManager::GetInstance().UnInitDeviceManager(packName);
3762 }
3763
3764 /**
3765 * @tc.name: UnRegisterDevStateCallback_006
3766 * @tc.desc: 1. set packName null
3767 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
3768 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3769 * deviceTypeId
3770 * @tc.type: FUNC
3771 * @tc.require: AR000GHSJK
3772 */
3773 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_006, testing::ext::TestSize.Level0)
3774 {
3775 // 1. set packName null
3776 std::string packName = "";
3777 // set extra null
3778 std::string extra= "";
3779 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3780 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3781 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3782 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3783 }
3784
3785 /**
3786 * @tc.name: UnRegisterDevStateCallback_007
3787 * @tc.desc: 1. set packName not null
3788 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
3789 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3790 * deviceTypeId
3791 * @tc.type: FUNC
3792 * @tc.require: AR000GHSJK
3793 */
3794 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_007, testing::ext::TestSize.Level0)
3795 {
3796 // 1. set packName null
3797 std::string packName = "";
3798 // set extra null
3799 std::string extra= "test";
3800 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3801 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3802 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3803 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3804 }
3805
3806 /**
3807 * @tc.name: UnRegisterDevStateCallback_008
3808 * @tc.desc: 1. set packName null
3809 * set extra not null
3810 * set callback null
3811 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3812 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3813 * deviceTypeId
3814 * @tc.type: FUNC
3815 * @tc.require: AR000GHSJK
3816 */
3817 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_008, testing::ext::TestSize.Level0)
3818 {
3819 // 1. set packName null
3820 std::string packName = "com.ohos.test";
3821 // set extra null
3822 std::string extra= "test";
3823 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3824 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3825 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3826 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3827 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
3828 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3829 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3830 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3831 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3832 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3833 }
3834
3835 /**
3836 * @tc.name: UnRegisterDevStateCallback_009
3837 * @tc.desc: 1. set packName null
3838 * set extra not null
3839 * set callback null
3840 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3841 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3842 * deviceTypeId
3843 * @tc.type: FUNC
3844 * @tc.require: AR000GHSJK
3845 */
3846 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_009, testing::ext::TestSize.Level0)
3847 {
3848 // 1. set packName null
3849 std::string packName = "com.ohos.test";
3850 // set extra null
3851 std::string extra= "test";
3852 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3853 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3854 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3855 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3856 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3857 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3858 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3859 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3860 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3861 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3862 }
3863
3864 /**
3865 * @tc.name: UnRegisterDevStateCallback_010
3866 * @tc.desc: 1. set packName not null
3867 * set extra not null
3868 * set callback null
3869 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3870 * 3. check ret is DM_OK
3871 * deviceTypeId
3872 * @tc.type: FUNC
3873 * @tc.require: AR000GHSJK
3874 */
3875 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_010, testing::ext::TestSize.Level0)
3876 {
3877 // 1. set packName null
3878 std::string packName = "com.ohos.test";
3879 // set extra null
3880 std::string extra= "test";
3881 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
3882 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
3883 // 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
3884 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3885 // 3. check ret is DM_OK
3886 ASSERT_EQ(ret, DM_OK);
3887 DeviceManager::GetInstance().UnInitDeviceManager(packName);
3888 }
3889
3890 /**
3891 * @tc.name: RequestCredential_001
3892 * @tc.desc: 1. set packName null
3893 * set reqJsonStr null
3894 * 2. call DeviceManagerImpl::RequestCredential with parameter
3895 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3896 * deviceTypeId
3897 * @tc.type: FUNC
3898 * @tc.require: AR000GHSJK
3899 */
3900 HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
3901 {
3902 std::string packName;
3903 std::string reqJsonStr;
3904 std::string returnJsonStr;
3905 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
3906 returnJsonStr);
3907 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3908 }
3909
3910 /**
3911 * @tc.name: RequestCredential_002
3912 * @tc.desc: 1. set packName not null
3913 * set reqJsonStr not null
3914 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
3915 * 3. call DeviceManagerImpl::RequestCredential with parameter
3916 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3917 * deviceTypeId
3918 * @tc.type: FUNC
3919 * @tc.require: AR000GHSJK
3920 */
3921 HWTEST_F(DeviceManagerImplTest, RequestCredential_002, testing::ext::TestSize.Level0)
3922 {
3923 std::string packName = "com.ohos.test";
3924 std::string reqJsonStr = R"({"version":"1.0.0.1","userId":"123"})";
3925 std::string returnJsonStr;
3926 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3927 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3928 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3929 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3930 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
3931 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
3932 returnJsonStr);
3933 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3934 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3935 }
3936
3937 /**
3938 * @tc.name: RequestCredential_003
3939 * @tc.desc: 1. set packName not null
3940 * set reqJsonStr not null
3941 * 2. MOCK IpcClientProxy SendRequest return DM_OK
3942 * 3. call DeviceManagerImpl::RequestCredential with parameter
3943 * 4. check ret is DM_OK
3944 * deviceTypeId
3945 * @tc.type: FUNC
3946 * @tc.require: AR000GHSJK
3947 */
3948 HWTEST_F(DeviceManagerImplTest, RequestCredential_003, testing::ext::TestSize.Level0)
3949 {
3950 std::string packName = "com.ohos.test";
3951 std::string reqJsonStr = R"(
3952 {
3953 "version":"1.0.0.1",
3954 "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
3955 }
3956 )";
3957 std::string returnJsonStr;
3958 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
3959 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
3960 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
3961 returnJsonStr);
3962 ASSERT_EQ(ret, DM_OK);
3963 DeviceManager::GetInstance().UnInitDeviceManager(packName);
3964 }
3965
3966 /**
3967 * @tc.name: RequestCredential_004
3968 * @tc.desc: 1. set packName not null
3969 * set reqJsonStr not null
3970 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3971 * 3. call DeviceManagerImpl::RequestCredential with parameter
3972 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3973 * deviceTypeId
3974 * @tc.type: FUNC
3975 * @tc.require: AR000GHSJK
3976 */
3977 HWTEST_F(DeviceManagerImplTest, RequestCredential_004, testing::ext::TestSize.Level0)
3978 {
3979 std::string packName = "com.ohos.test";
3980 std::string reqJsonStr = R"({"version":"1.0.0.1","userId":"123"})";
3981 std::string returnJsonStr;
3982 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3983 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
3984 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3985 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3986 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3987 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
3988 returnJsonStr);
3989 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3990 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
3991 }
3992
3993 /**
3994 * @tc.name: ImportCredential_001
3995 * @tc.desc: 1. set packName null
3996 * set reqJsonStr null
3997 * 2. call DeviceManagerImpl::ImportCredential with parameter
3998 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3999 * deviceTypeId
4000 * @tc.type: FUNC
4001 * @tc.require: AR000GHSJK
4002 */
4003 HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
4004 {
4005 std::string packName;
4006 std::string credentialInfo;
4007 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
4008 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4009 }
4010
4011 /**
4012 * @tc.name: ImportCredential_002
4013 * @tc.desc: 1. set packName not null
4014 * set credentialInfo not null
4015 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
4016 * 3. call DeviceManagerImpl::ImportCredential with parameter
4017 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
4018 * deviceTypeId
4019 * @tc.type: FUNC
4020 * @tc.require: AR000GHSJK
4021 */
4022 HWTEST_F(DeviceManagerImplTest, ImportCredential_002, testing::ext::TestSize.Level0)
4023 {
4024 std::string packName = "com.ohos.test";
4025 std::string credentialInfo = R"(
4026 {
4027 "processType": 1,
4028 "authType": 1,
4029 "userId": "123",
4030 "credentialData":
4031 [
4032 {
4033 "credentialType": 1,
4034 "credentialId": "104",
4035 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
4036 "serverPk": "",
4037 "pkInfoSignature": "",
4038 "pkInfo": "",
4039 "peerDeviceId": ""
4040 }
4041 ]
4042 }
4043 )";
4044 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4045 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4046 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4047 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4048 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
4049 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
4050 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
4051 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4052 }
4053
4054 /**
4055 * @tc.name: ImportCredential_003
4056 * @tc.desc: 1. set packName not null
4057 * set credentialInfo not null
4058 * 2. MOCK IpcClientProxy SendRequest return DM_OK
4059 * 3. call DeviceManagerImpl::ImportCredential with parameter
4060 * 4. check ret is DM_OK
4061 * deviceTypeId
4062 * @tc.type: FUNC
4063 * @tc.require: AR000GHSJK
4064 */
4065 HWTEST_F(DeviceManagerImplTest, ImportCredential_003, testing::ext::TestSize.Level0)
4066 {
4067 std::string packName = "com.ohos.test";
4068 std::string credentialInfo = R"(
4069 {
4070 "processType": 1,
4071 "authType": 1,
4072 "userId": "123",
4073 "credentialData":
4074 [
4075 {
4076 "credentialType": 1,
4077 "credentialId": "104",
4078 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
4079 "serverPk": "",
4080 "pkInfoSignature": "",
4081 "pkInfo": "",
4082 "peerDeviceId": ""
4083 }
4084 ]
4085 }
4086 )";
4087 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4088 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4089 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4090 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4091 .Times(1).WillOnce(testing::Return(DM_OK));
4092 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
4093 ASSERT_EQ(ret, DM_OK);
4094 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4095 }
4096
4097 /**
4098 * @tc.name: ImportCredential_004
4099 * @tc.desc: 1. set packName not null
4100 * set credentialInfo not null
4101 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
4102 * 3. call DeviceManagerImpl::ImportCredential with parameter
4103 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
4104 * deviceTypeId
4105 * @tc.type: FUNC
4106 * @tc.require: AR000GHSJK
4107 */
4108 HWTEST_F(DeviceManagerImplTest, ImportCredential_004, testing::ext::TestSize.Level0)
4109 {
4110 std::string packName = "com.ohos.test";
4111 std::string credentialInfo = R"(
4112 {
4113 "processType": 1,
4114 "authType": 1,
4115 "userId": "123",
4116 "credentialData":
4117 [
4118 {
4119 "credentialType": 1,
4120 "credentialId": "104",
4121 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
4122 "serverPk": "",
4123 "pkInfoSignature": "",
4124 "pkInfo": "",
4125 "peerDeviceId": ""
4126 }
4127 ]
4128 }
4129 )";
4130 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4131 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4132 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4133 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4134 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
4135 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
4136 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
4137 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4138 }
4139
4140 /**
4141 * @tc.name: DeleteCredential_001
4142 * @tc.desc: 1. set packName null
4143 * set deleteInfo null
4144 * 2. call DeviceManagerImpl::DeleteCredential with parameter
4145 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4146 * deviceTypeId
4147 * @tc.type: FUNC
4148 * @tc.require: AR000GHSJK
4149 */
4150 HWTEST_F(DeviceManagerImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)
4151 {
4152 std::string packName;
4153 std::string deleteInfo;
4154 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
4155 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4156 }
4157
4158 /**
4159 * @tc.name: DeleteCredential_002
4160 * @tc.desc: 1. set packName not null
4161 * set deleteInfo not null
4162 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
4163 * 3. call DeviceManagerImpl::DeleteCredential with parameter
4164 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
4165 * deviceTypeId
4166 * @tc.type: FUNC
4167 * @tc.require: AR000GHSJK
4168 */
4169 HWTEST_F(DeviceManagerImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)
4170 {
4171 std::string packName = "com.ohos.test";
4172 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
4173 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4174 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4175 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4176 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4177 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
4178 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
4179 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
4180 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4181 }
4182
4183 /**
4184 * @tc.name: DeleteCredential_003
4185 * @tc.desc: 1. set packName not null
4186 * set deleteInfo not null
4187 * 2. MOCK IpcClientProxy SendRequest return DM_OK
4188 * 3. call DeviceManagerImpl::DeleteCredential with parameter
4189 * 4. check ret is DM_OK
4190 * deviceTypeId
4191 * @tc.type: FUNC
4192 * @tc.require: AR000GHSJK
4193 */
4194 HWTEST_F(DeviceManagerImplTest, DeleteCredential_003, testing::ext::TestSize.Level0)
4195 {
4196 std::string packName = "com.ohos.test";
4197 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
4198 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4199 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4200 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4201 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4202 .Times(1).WillOnce(testing::Return(DM_OK));
4203 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
4204 ASSERT_EQ(ret, DM_OK);
4205 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4206 }
4207
4208 /**
4209 * @tc.name: DeleteCredential_004
4210 * @tc.desc: 1. set packName not null
4211 * set credentialInfo not null
4212 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
4213 * 3. call DeviceManagerImpl::DeleteCredential with parameter
4214 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
4215 * deviceTypeId
4216 * @tc.type: FUNC
4217 * @tc.require: AR000GHSJK
4218 */
4219 HWTEST_F(DeviceManagerImplTest, DeleteCredential_004, testing::ext::TestSize.Level0)
4220 {
4221 std::string packName = "com.ohos.test";
4222 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
4223 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4224 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4225 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4226 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4227 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
4228 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
4229 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
4230 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4231 }
4232
4233 /**
4234 * @tc.name: RegisterCredentialCallback_001
4235 * @tc.desc: 1. set packName null
4236 * set callback null
4237 * 3. call DeviceManagerImpl::RegisterCredentialCallback with parameter
4238 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
4239 * deviceTypeId
4240 * @tc.type: FUNC
4241 * @tc.require: AR000GHSJK
4242 */
4243 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
4244 {
4245 std::string packName = "";
4246 std::shared_ptr<CredentialCallbackTest> callback = nullptr;
4247 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
4248 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4249 }
4250
4251 /**
4252 * @tc.name: RegisterCredentialCallback_002
4253 * @tc.desc: 1. set packName not null
4254 * set callback not null
4255 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
4256 * 3. check ret is DM_OK
4257 * deviceTypeId
4258 * @tc.type: FUNC
4259 * @tc.require: AR000GHSJK
4260 */
4261 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
4262 {
4263 std::string packName = "com.ohos.test";
4264 std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
4265 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
4266 DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
4267 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
4268 ASSERT_EQ(ret, DM_OK);
4269 DeviceManager::GetInstance().UnInitDeviceManager(packName);
4270 }
4271
4272 /**
4273 * @tc.name: RegisterCredentialCallback_003
4274 * @tc.desc: 1. set packName not null
4275 * set callback null
4276 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
4277 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4278 * deviceTypeId
4279 * @tc.type: FUNC
4280 * @tc.require: AR000GHSJK
4281 */
4282 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_003, testing::ext::TestSize.Level0)
4283 {
4284 std::string packName = "com.ohos.test";
4285 std::shared_ptr<CredentialCallbackTest> callback = nullptr;
4286 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
4287 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4288 }
4289
4290 /**
4291 * @tc.name: RegisterCredentialCallback_004
4292 * @tc.desc: 1. set packName null
4293 * set callback not null
4294 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
4295 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4296 * deviceTypeId
4297 * @tc.type: FUNC
4298 * @tc.require: AR000GHSJK
4299 */
4300 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_004, testing::ext::TestSize.Level0)
4301 {
4302 std::string packName = "";
4303 std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
4304 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
4305 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4306 }
4307
4308 /**
4309 * @tc.name: UnRegisterCredentialCallback_001
4310 * @tc.desc: 1. set packName null
4311 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
4312 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4313 * deviceTypeId
4314 * @tc.type: FUNC
4315 * @tc.require: AR000GHSJK
4316 */
4317 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
4318 {
4319 std::string packName = "";
4320 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
4321 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4322 }
4323
4324 /**
4325 * @tc.name: UnRegisterCredentialCallback_002
4326 * @tc.desc: 1. set packName not null
4327 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
4328 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
4329 * deviceTypeId
4330 * @tc.type: FUNC
4331 * @tc.require: AR000GHSJK
4332 */
4333 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
4334 {
4335 std::string packName = "com.ohos.test";
4336 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4337 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4338 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4339 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4340 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
4341 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
4342 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
4343 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4344 }
4345
4346 /**
4347 * @tc.name: UnRegisterCredentialCallback_003
4348 * @tc.desc: 1. set packName not null
4349 * set callback null
4350 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
4351 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
4352 * deviceTypeId
4353 * @tc.type: FUNC
4354 * @tc.require: AR000GHSJK
4355 */
4356 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_003, testing::ext::TestSize.Level0)
4357 {
4358 // 1. set packName null
4359 std::string packName = "com.ohos.test";
4360 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4361 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4362 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4363 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4364 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
4365 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
4366 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
4367 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4368 }
4369
4370 /**
4371 * @tc.name: UnRegisterCredentialCallback_004
4372 * @tc.desc: 1. set packName not null
4373 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
4374 * 3. check ret is DM_OK
4375 * deviceTypeId
4376 * @tc.type: FUNC
4377 * @tc.require: AR000GHSJK
4378 */
4379 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_004, testing::ext::TestSize.Level0)
4380 {
4381 std::string packName = "com.ohos.test";
4382 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
4383 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
4384 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
4385 ASSERT_EQ(ret, DM_OK);
4386 DeviceManager::GetInstance().UnInitDeviceManager(packName);
4387 }
4388
4389 /**
4390 * @tc.name: OnDmServiceDied_001
4391 * @tc.desc: 1. mock IpcClientProxy
4392 * 2. call DeviceManagerImpl::OnDmServiceDied
4393 * 3. check ret is DM_OK
4394 * deviceTypeId
4395 * @tc.type: FUNC
4396 * @tc.require: AR000GHSJK
4397 */
4398 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_001, testing::ext::TestSize.Level0)
4399 {
4400 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4401 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4402 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4403 int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied();
4404 ASSERT_EQ(ret, DM_OK);
4405 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4406 }
4407
4408 /**
4409 * @tc.name: OnDmServiceDied_001
4410 * @tc.desc: 1. mock IpcClientProxy
4411 * 2. call DeviceManagerImpl::OnDmServiceDied
4412 * 3. check ret is DM_OK
4413 * deviceTypeId
4414 * @tc.type: FUNC
4415 * @tc.require: AR000GHSJK
4416 */
4417 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_002, testing::ext::TestSize.Level0)
4418 {
4419 // 1. mock IpcClientProxy
4420 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4421 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4422 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4423 EXPECT_CALL(*mockInstance, OnDmServiceDied()).Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
4424 // 2. call DeviceManagerImpl::OnDmServiceDied
4425 int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied();
4426 // 3. check ret is DM_OK
4427 ASSERT_EQ(ret, ERR_DM_FAILED);
4428 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4429 }
4430
4431 /**
4432 * @tc.name: NotifyEvent_001
4433 * @tc.desc: 1. mock IpcClientProxy
4434 * 2. call DeviceManagerImpl::NotifyEvent
4435 * 3. check ret is DM_OK
4436 * deviceTypeId
4437 * @tc.type: FUNC
4438 */
4439 HWTEST_F(DeviceManagerImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)
4440 {
4441 std::string packName = "com.ohos.test";
4442 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
4443 std::string event = R"({"extra": {"deviceId": "123"})";
4444 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
4445 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
4446 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
4447 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
4448 .Times(1).WillOnce(testing::Return(DM_OK));
4449 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
4450 ASSERT_EQ(ret, DM_OK);
4451 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
4452 }
4453
4454 /**
4455 * @tc.name: NotifyEvent_002
4456 * @tc.desc: 1. mock IpcClientProxy
4457 * 2. call DeviceManagerImpl::NotifyEvent
4458 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4459 * deviceTypeId
4460 * @tc.type: FUNC
4461 */
4462 HWTEST_F(DeviceManagerImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)
4463 {
4464 std::string packName = "";
4465 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
4466 std::string event = R"({"extra": {"deviceId": "123"})";
4467 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
4468 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4469 }
4470
4471 /**
4472 * @tc.name: NotifyEvent_003
4473 * @tc.desc: 1. mock IpcClientProxy
4474 * 2. call DeviceManagerImpl::NotifyEvent
4475 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4476 * deviceTypeId
4477 * @tc.type: FUNC
4478 */
4479 HWTEST_F(DeviceManagerImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)
4480 {
4481 std::string packName = "com.ohos.test";
4482 int32_t eventId = DM_NOTIFY_EVENT_START;
4483 std::string event = R"({"extra": {"deviceId": "123"})";
4484 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
4485 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4486 }
4487
4488 /**
4489 * @tc.name: NotifyEvent_004
4490 * @tc.desc: 1. mock IpcClientProxy
4491 * 2. call DeviceManagerImpl::NotifyEvent
4492 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4493 * deviceTypeId
4494 * @tc.type: FUNC
4495 */
4496 HWTEST_F(DeviceManagerImplTest, NotifyEvent_004, testing::ext::TestSize.Level0)
4497 {
4498 std::string packName = "com.ohos.test";
4499 int32_t eventId = DM_NOTIFY_EVENT_BUTT;
4500 std::string event = R"({"extra": {"deviceId": "123"})";
4501 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
4502 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4503 }
4504
4505 /**
4506 * @tc.name: CheckAPIAccessPermission_001
4507 * @tc.desc: 1. InitDeviceManager
4508 * 2. call DeviceManagerImpl::CheckAPIAccessPermission
4509 * 3. check ret is DM_OK
4510 * 4. UnInitDeviceManager
4511 * deviceTypeId
4512 * @tc.type: FUNC
4513 */
4514 HWTEST_F(DeviceManagerImplTest, CheckAPIAccessPermission_001, testing::ext::TestSize.Level0)
4515 {
4516 std::string packName = "com.ohos.test";
4517 std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
4518 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
4519 DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
4520 int32_t ret = DeviceManager::GetInstance().CheckAPIAccessPermission();
4521 ASSERT_EQ(ret, DM_OK);
4522 DeviceManager::GetInstance().UnInitDeviceManager(packName);
4523 }
4524
4525 /**
4526 * @tc.name: RegisterDevStatusCallback_001
4527 * @tc.desc: 1. InitDeviceManager
4528 * 2. call DeviceManagerImpl::RegisterDevStatusCallback
4529 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4530 * deviceTypeId
4531 * @tc.type: FUNC
4532 */
4533 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_001, testing::ext::TestSize.Level0)
4534 {
4535 std::string pkgName;
4536 std::string extra;
4537 std::shared_ptr<DeviceStatusCallback> callback = nullptr;
4538 int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(pkgName, extra, callback);
4539 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4540 }
4541
4542 /**
4543 * @tc.name: RegisterDevStatusCallback_002
4544 * @tc.desc: 1. InitDeviceManager
4545 * 2. call DeviceManagerImpl::RegisterDevStatusCallback
4546 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4547 * deviceTypeId
4548 * @tc.type: FUNC
4549 */
4550 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_002, testing::ext::TestSize.Level0)
4551 {
4552 std::string packName = "com.ohos.test";
4553 std::string extra;
4554 std::shared_ptr<DeviceStatusCallback> callback = nullptr;
4555 int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(packName, extra, callback);
4556 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4557 }
4558
4559 /**
4560 * @tc.name: RegisterDevStatusCallback_003
4561 * @tc.desc: 1. InitDeviceManager
4562 * 2. call DeviceManagerImpl::RegisterDevStatusCallback
4563 * 3. check ret is DM_OK
4564 * deviceTypeId
4565 * @tc.type: FUNC
4566 */
4567 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_003, testing::ext::TestSize.Level0)
4568 {
4569 std::string packName = "com.ohos.test";
4570 std::string extra;
4571 std::shared_ptr<DeviceStatusCallback> callback = std::make_shared<DeviceStatusCallbackTest>();
4572 int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(packName, extra, callback);
4573 ASSERT_EQ(ret, DM_OK);
4574 }
4575
4576 /**
4577 * @tc.name: UnRegisterDevStatusCallback_001
4578 * @tc.desc: 1. InitDeviceManager
4579 * 2. call DeviceManagerImpl::UnRegisterDevStatusCallback
4580 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
4581 * deviceTypeId
4582 * @tc.type: FUNC
4583 */
4584 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_001, testing::ext::TestSize.Level0)
4585 {
4586 std::string packName;
4587 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStatusCallback(packName);
4588 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4589 }
4590
4591 /**
4592 * @tc.name: UnRegisterDevStatusCallback_002
4593 * @tc.desc: 1. InitDeviceManager
4594 * 2. call DeviceManagerImpl::UnRegisterDevStatusCallback
4595 * 3. check ret is DM_OK
4596 * deviceTypeId
4597 * @tc.type: FUNC
4598 */
4599 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_002, testing::ext::TestSize.Level0)
4600 {
4601 std::string packName = "com.ohos.test";
4602 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStatusCallback(packName);
4603 ASSERT_EQ(ret, DM_OK);
4604 }
4605
4606 /**
4607 * @tc.name: StartDeviceDiscovery_104
4608 * @tc.desc: 1. set packName null
4609 * set subscribeId 0
4610 * set filterOptions null
4611 * set callback not null
4612 * 2. InitDeviceManager return DM_OK
4613 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
4614 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
4615 * deviceTypeId
4616 * @tc.type: FUNC
4617 * @tc.require: AR000GHSJK
4618 */
4619 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_104, testing::ext::TestSize.Level0)
4620 {
4621 std::string packName;
4622 uint16_t subscribeId = 0;
4623 std::string filterOptions;
4624 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
4625 DmDeviceBasicInfo deviceBasicInfo;
4626 callback->OnDeviceFound(subscribeId, deviceBasicInfo);
4627 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
4628 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
4629 ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
4630 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4631 DeviceManager::GetInstance().UnInitDeviceManager(packName);
4632 }
4633
4634 /**
4635 * @tc.name: StartDeviceDiscovery_105
4636 * @tc.desc: 1. set packName not null
4637 * set subscribeId 0
4638 * set filterOptions null
4639 * set callback not null
4640 * 2. InitDeviceManager return DM_OK
4641 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
4642 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
4643 * deviceTypeId
4644 * @tc.type: FUNC
4645 * @tc.require: AR000GHSJK
4646 */
4647 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_105, testing::ext::TestSize.Level0)
4648 {
4649 std::string packName = "com.ohos.test";
4650 uint16_t subscribeId = 0;
4651 std::string filterOptions;
4652 std::shared_ptr<DiscoveryCallback> callback = nullptr;
4653 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
4654 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
4655 }
4656
4657 /**
4658 * @tc.name: StartDeviceDiscovery_106
4659 * @tc.desc: 1. set packName not null
4660 * set subscribeId 0
4661 * set filterOptions not null
4662 * set callback not null
4663 * 2. InitDeviceManager return DM_OK
4664 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
4665 * 4. check ret is DM_OK
4666 * deviceTypeId
4667 * @tc.type: FUNC
4668 * @tc.require: AR000GHSJK
4669 */
4670 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_106, testing::ext::TestSize.Level0)
4671 {
4672 std::string packName = "com.ohos.test";
4673 uint16_t subscribeId = 0;
4674 std::string filterOptions = "filterOptions";
4675 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
4676 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
4677 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
4678 DeviceManagerImpl::GetInstance().subscribIdMap_.clear();
4679 ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
4680 ASSERT_EQ(ret, DM_OK);
4681 DeviceManager::GetInstance().UnInitDeviceManager(packName);
4682 }
4683 } // namespace
4684 } // namespace DistributedHardware
4685 } // namespace OHOS