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