1 /*
2 * Copyright (c) 2022 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 "device_manager_notify.h"
21 #include "dm_constants.h"
22 #include "dm_log.h"
23 #include "ipc_authenticate_device_req.h"
24 #include "ipc_get_dmfaparam_rsp.h"
25 #include "ipc_get_info_by_network_req.h"
26 #include "ipc_get_info_by_network_rsp.h"
27 #include "ipc_get_local_device_info_rsp.h"
28 #include "ipc_get_trustdevice_req.h"
29 #include "ipc_get_trustdevice_rsp.h"
30 #include "ipc_req.h"
31 #include "ipc_rsp.h"
32 #include "ipc_set_useroperation_req.h"
33 #include "ipc_skeleton.h"
34 #include "ipc_start_discovery_req.h"
35 #include "ipc_stop_discovery_req.h"
36 #include "ipc_publish_req.h"
37 #include "ipc_unpublish_req.h"
38 #include "ipc_unauthenticate_device_req.h"
39 #include "ipc_verify_authenticate_req.h"
40 #include "securec.h"
41
42 namespace OHOS {
43 namespace DistributedHardware {
SetUp()44 void DeviceManagerImplTest::SetUp()
45 {
46 }
47
TearDown()48 void DeviceManagerImplTest::TearDown()
49 {
50 }
51
SetUpTestCase()52 void DeviceManagerImplTest::SetUpTestCase()
53 {
54 }
55
TearDownTestCase()56 void DeviceManagerImplTest::TearDownTestCase()
57 {
58 }
59
60 namespace {
61 /**
62 * @tc.name: InitDeviceManager_001
63 * @tc.desc: 1. set packName not null
64 * set dmInitCallback not null
65 * 2. call DeviceManagerImpl::InitDeviceManager with parameter
66 * 4. check ret is DM_OK
67 * deviceTypeId
68 * @tc.type: FUNC
69 * @tc.require: AR000GHSJK
70 */
71 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_101, testing::ext::TestSize.Level0)
72 {
73 // 1. set packName not null
74 std::string packName = "com.ohos.test";
75 // set dmInitCallback not null
76 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
77 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
78 // 3. check ret is DM_OK
79 ASSERT_EQ(ret, DM_OK);
80 DeviceManager::GetInstance().UnInitDeviceManager(packName);
81 }
82
83 /**
84 * @tc.name: UnInitDeviceManager_101
85 * @tc.desc: 1. set packName not null
86 * 2. MOCK IpcClientProxy UnInit return DM_OK
87 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
88 * 4. check ret is DM_OK
89 * deviceTypeId
90 * @tc.type: FUNC
91 * @tc.require: AR000GHSJK
92 */
93 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_101, testing::ext::TestSize.Level0)
94 {
95 std::string packName = "com.ohos.test2";
96 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
97 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
98 ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
99 ASSERT_EQ(ret, DM_OK);
100 }
101
102 /**
103 * @tc.name: GetTrustedDeviceList_101
104 * @tc.desc: 1. set packName not null
105 * set extra null
106 * set deviceList null
107 * 2. MOCK IpcClientProxy SendRequest return DM_OK
108 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
109 * 4. check ret is DM_OK
110 * deviceTypeId
111 * @tc.type: FUNC
112 * @tc.require: AR000GHSJK
113 */
114 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_101, testing::ext::TestSize.Level0)
115 {
116 // 1. set packName not null
117 std::string packName = "com.ohos.test";
118 // set extra null
119 std::string extra = "";
120 // set deviceList null
121 std::vector<DmDeviceInfo> deviceList;
122 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
123 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
124 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
125 ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
126 // 3. check ret is DM_OK
127 ASSERT_EQ(ret, DM_OK);
128 DeviceManager::GetInstance().UnInitDeviceManager(packName);
129 }
130
131 /**
132 * @tc.name: GetLocalDeviceInfo_101
133 * @tc.desc: 1. set packName null
134 * set extra null
135 * set deviceList null
136 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
137 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
138 * deviceTypeId
139 * @tc.type: FUNC
140 * @tc.require: AR000GHSJK
141 */
142 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_101, testing::ext::TestSize.Level0)
143 {
144 // 1. set packName not null
145 std::string packName = "com.ohos.test";
146 // set extra null
147 DmDeviceInfo info;
148 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
149 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
150 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
151 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
152 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
153 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
154 ASSERT_EQ(ret, DM_OK);
155 DeviceManager::GetInstance().UnInitDeviceManager(packName);
156 }
157
158 /**
159 * @tc.name: StartDeviceDiscovery_101
160 * @tc.desc: 1. set packName not null
161 * set subscribeInfo null
162 * set callback not null
163 * 2. InitDeviceManager return DM_OK
164 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
165 * 4. check ret is ERR_DM_DISCOVERY_FAILED
166 * deviceTypeId
167 * @tc.type: FUNC
168 * @tc.require: AR000GHSJK
169 */
170 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_101, testing::ext::TestSize.Level0)
171 {
172 // 1. set packName not null
173 std::string packName = "com.ohos.helloworld";
174 std::string extra= "";
175 // set subscribeInfo null
176 DmSubscribeInfo subscribeInfo;
177 // set callback not null
178 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
179 // 2. InitDeviceManager return DM_OK
180 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
181 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
182 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
183 ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
184 // 4. check ret is ERR_DM_DISCOVERY_FAILED
185 ASSERT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
186 DeviceManager::GetInstance().UnInitDeviceManager(packName);
187 }
188
189 /**
190 * @tc.name: StopDeviceDiscovery_101
191 * @tc.desc: 1. set packName not null
192 * set subscribeId is 0
193 * 2. InitDeviceManager return DM_OK
194 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
195 * 4. check ret is ERR_DM_DISCOVERY_FAILED
196 * deviceTypeId
197 * @tc.type: FUNC
198 * @tc.require: AR000GHSJK
199 */
200 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_101, testing::ext::TestSize.Level0)
201 {
202 // 1. set packName not null
203 std::string packName = "com.ohos.test";
204 // set subscribeInfo is 0
205 uint16_t subscribeId = 0;
206 // 2. InitDeviceManager return DM_OK
207 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
208 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
209 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
210 ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
211 // 4. check ret is DM_OK
212 ASSERT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
213 DeviceManager::GetInstance().UnInitDeviceManager(packName);
214 }
215
216 /**
217 * @tc.name: PublishDeviceDiscovery_101
218 * @tc.desc: 1. set packName not null
219 * set publishInfo null
220 * set callback not null
221 * 2. InitDeviceManager return DM_OK
222 * 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
223 * 4. check ret is ERR_DM_PUBLISH_FAILED
224 * deviceTypeId
225 * @tc.type: FUNC
226 * @tc.require: I5N1K3
227 */
228 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_101, testing::ext::TestSize.Level0)
229 {
230 // 1. set packName not null
231 std::string packName = "com.ohos.helloworld";
232 // set publishInfo null
233 DmPublishInfo publishInfo;
234 // set callback not null
235 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
236 // 2. InitDeviceManager return DM_OK
237 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
238 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
239 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
240 ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
241 // 4. check ret is ERR_DM_PUBLISH_FAILED
242 ASSERT_EQ(ret, ERR_DM_PUBLISH_FAILED);
243 DeviceManager::GetInstance().UnInitDeviceManager(packName);
244 }
245
246 /**
247 * @tc.name: UnPublishDeviceDiscovery_101
248 * @tc.desc: 1. set packName not null
249 * set publishId is 0
250 * 2. InitDeviceManager return DM_OK
251 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
252 * 4. check ret is ERR_DM_PUBLISH_FAILED
253 * deviceTypeId
254 * @tc.type: FUNC
255 * @tc.require: I5N1K3
256 */
257 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_101, testing::ext::TestSize.Level0)
258 {
259 // 1. set packName not null
260 std::string packName = "com.ohos.test";
261 // set subscribeInfo is 0
262 int32_t publishId = 0;
263 // 2. InitDeviceManager return DM_OK
264 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
265 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
266 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
267 ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
268 // 4. check ret is ERR_DM_PUBLISH_FAILED
269 ASSERT_EQ(ret, ERR_DM_PUBLISH_FAILED);
270 DeviceManager::GetInstance().UnInitDeviceManager(packName);
271 }
272
273 /**
274 * @tc.name: AuthenticateDevice_101
275 * @tc.desc: 1. set packName not null
276 * set dmDeviceInfo null
277 * set dmAppImageInfo null
278 * set extra null
279 * set callback null
280 * 2. InitDeviceManager return DM_OK
281 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
282 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
283 * deviceTypeId
284 * @tc.type: FUNC
285 * @tc.require: AR000GHSJK
286 */
287 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_101, testing::ext::TestSize.Level0)
288 {
289 // 1. set packName not null
290 std::string packName = "com.ohos.helloworld";
291 // set dmDeviceInfo null
292 int32_t authType = 1;
293 // set dmAppImageInfo null
294 DmDeviceInfo dmDeviceInfo;
295 strcpy_s(dmDeviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, "123XXXX");
296 strcpy_s(dmDeviceInfo.deviceName, DM_MAX_DEVICE_NAME_LEN, "234");
297 dmDeviceInfo.deviceTypeId = 0;
298 // set extra null
299 std::string extra = "test";
300 // set callback null
301 std::shared_ptr<AuthenticateCallback> callback = nullptr;
302 // 2.InitDeviceManager return DM_OK
303 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
304 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
305 ASSERT_EQ(ret, DM_OK);
306 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
307 ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
308 // 4. check ret is DM_OK
309 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
310 DeviceManager::GetInstance().UnInitDeviceManager(packName);
311 }
312
313 /**
314 * @tc.name: UnAuthenticateDevice_101
315 * @tc.desc: 1. set packName not null
316 * set dmDeviceInfo null
317 * set dmAppImageInfo null
318 * set extra null
319 * set callback null
320 * 2. InitDeviceManager return DM_OK
321 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
322 * 4. check ret is ERR_DM_FAILED
323 * deviceTypeId
324 * @tc.type: FUNC
325 * @tc.require: AR000GHSJK
326 */
327 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_101, testing::ext::TestSize.Level0)
328 {
329 // 1. set packName not null
330 std::string packName = "com.ohos.helloworld";
331 DmDeviceInfo deviceInfo;
332 deviceInfo.deviceId[0] = '1';
333 deviceInfo.deviceId[1] = '2';
334 deviceInfo.deviceId[2] = '\0';
335 // set callback null
336 std::shared_ptr<AuthenticateCallback> callback = nullptr;
337 // 2. InitDeviceManager return DM_OK
338 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
339 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
340 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
341 ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
342 // 4. check ret is ERR_DM_FAILED
343 ASSERT_EQ(ret, ERR_DM_FAILED);
344 DeviceManager::GetInstance().UnInitDeviceManager(packName);
345 }
346
347 /**
348 * @tc.name: SetUserOperation_101
349 * @tc.desc: 1. set packName not null
350 * set action null
351 * 2. InitDeviceManager return DM_OK
352 * 3. call DeviceManagerImpl::SetUserOperation with parameter
353 * 4. check ret is DM_OK
354 * deviceTypeId
355 * @tc.type: FUNC
356 * @tc.require: AR000GHSJK
357 */
358 HWTEST_F(DeviceManagerImplTest, SetUserOperation_101, testing::ext::TestSize.Level0)
359 {
360 // 1. set packName not null
361 std::string packName = "com.ohos.test";
362 // set authParam null
363 int32_t action = 0;
364 const std::string param = "extra";
365 // 2. InitDeviceManager return DM_OK
366 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
367 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
368 // 3. call DeviceManagerImpl::SetUserOperation with parameter
369 ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
370 // 4. check ret is DM_OK
371 ASSERT_EQ(ret, DM_OK);
372 DeviceManager::GetInstance().UnInitDeviceManager(packName);
373 }
374
375 /**
376 * @tc.name: InitDeviceManager_001
377 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt
378 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
379 * deviceTypeId
380 * @tc.type: FUNC
381 * @tc.require: AR000GHSJK
382 */
383 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_001, testing::ext::TestSize.Level0)
384 {
385 // 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt
386 std::string packName = "";
387 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr;
388 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, dmInitCallback);
389 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
390 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
391 }
392
393 /**
394 * @tc.name: InitDeviceManager_002
395 * @tc.desc: 1. set packName not null
396 * set dmInitCallback not null
397 * 2. MOCK IpcClientProxy Init return DM_OK
398 * 3. call DeviceManagerImpl::InitDeviceManager with parameter
399 * 4. check ret is DM_OK
400 * deviceTypeId
401 * @tc.type: FUNC
402 * @tc.require: AR000GHSJK
403 */
404 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_002, testing::ext::TestSize.Level0)
405 {
406 // 1. set packName not null
407 std::string packName = "com.ohos.test";
408 // set dmInitCallback not null
409 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
410 // 2. MOCK IpcClientProxy Init return ERR_DM_FAILED
411 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
412 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
413 EXPECT_CALL(*mockInstance, Init(testing::_)).Times(1).WillOnce(testing::Return(DM_OK));
414 // 3. call DeviceManagerImpl::InitDeviceManager with parameter
415 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
416 // 4. check ret is DM_OK
417 ASSERT_EQ(ret, DM_OK);
418 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
419 }
420
421 /**
422 * @tc.name: InitDeviceManager_003
423 * @tc.desc: 1. set packName not null
424 * set dmInitCallback not null
425 * 2. MOCK IpcClientProxy Init return ERR_DM_INIT_FAILED
426 * 3. call DeviceManagerImpl::InitDeviceManager with parameter
427 * 4. check ret is ERR_DM_INIT_FAILED
428 * deviceTypeId
429 * @tc.type: FUNC
430 * @tc.require: AR000GHSJK
431 */
432 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_003, testing::ext::TestSize.Level0)
433 {
434 // 1. set packName not null
435 std::string packName = "com.ohos.test";
436 // set dmInitCallback not null
437 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
438 // 2. MOCK IpcClientProxy Init return ERR_DM_FAILED
439 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
440 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
441 EXPECT_CALL(*mockInstance, Init(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
442 // 3. call DeviceManagerImpl::InitDeviceManager with parameter
443 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
444 // 4. check ret is ERR_DM_INIT_FAILED
445 ASSERT_EQ(ret, ERR_DM_INIT_FAILED);
446 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
447 }
448
449 /**
450 * @tc.name: InitDeviceManager_004
451 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
452 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
453 * deviceTypeId
454 * @tc.type: FUNC
455 * @tc.require: AR000GHSJK
456 */
457 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_004, testing::ext::TestSize.Level0)
458 {
459 // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
460 std::string packName = "com.ohos.test";
461 std::shared_ptr<DmInitCallbackTest> callback = nullptr;
462 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
463 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
464 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
465 }
466
467 /**
468 * @tc.name: InitDeviceManager_005
469 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
470 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
471 * deviceTypeId
472 * @tc.type: FUNC
473 * @tc.require: AR000GHSJK
474 */
475 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_005, testing::ext::TestSize.Level0)
476 {
477 // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
478 std::string packName = "";
479 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
480 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
481 // 2. check ret is ERR_DM_INPUT_PARA_INVALID
482 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
483 }
484
485 /**
486 * @tc.name: UnInitDeviceManager_001
487 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
488 * 2. check ret is ERR_DM_INPUT_PARA_INVALID
489 * deviceTypeId
490 * @tc.type: FUNC
491 * @tc.require: AR000GHSJK
492 */
493 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_001, testing::ext::TestSize.Level0)
494 {
495 // 1. set packName not null
496 std::string packName = "";
497 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
498 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
499 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
500 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
501 }
502
503 /**
504 * @tc.name: UnInitDeviceManager_002
505 * @tc.desc: 1. set packName not null
506 * 2. MOCK IpcClientProxy UnInit return ERR_DM_FAILED
507 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
508 * 4. check ret is ERR_DM_FAILED
509 * deviceTypeId
510 * @tc.type: FUNC
511 * @tc.require: AR000GHSJK
512 */
513 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_002, testing::ext::TestSize.Level0)
514 {
515 // 1. set packName not null
516 std::string packName = "com.ohos.test";
517 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
518 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
519 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
520 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
521 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
522 // 3. check ret is ERR_DM_FAILED
523 ASSERT_EQ(ret, ERR_DM_FAILED);
524 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
525 }
526
527 /**
528 * @tc.name: UnInitDeviceManager_003
529 * @tc.desc: 1. set packName not null
530 * 2. MOCK IpcClientProxy UnInit return DM_OK
531 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
532 * 4. check ret is DM_OK
533 * deviceTypeId
534 * @tc.type: FUNC
535 * @tc.require: AR000GHSJK
536 */
537 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_003, testing::ext::TestSize.Level0)
538 {
539 // 1. set packName not null
540 std::string packName = "com.ohos.test";
541 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
542 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
543 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
544 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(DM_OK));
545 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
546 // 3. check ret is DM_OK
547 ASSERT_EQ(ret, DM_OK);
548 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
549 }
550
551 /**
552 * @tc.name: UnInitDeviceManager_004
553 * @tc.desc: 1. set packName not null
554 * 2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED
555 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
556 * 4. check ret is ERR_DM_FAILED
557 * deviceTypeId
558 * @tc.type: FUNC
559 * @tc.require: AR000GHSJK
560 */
561 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_004, testing::ext::TestSize.Level0)
562 {
563 // 1. set packNamen not null
564 std::string packName = "com.ohos.test";
565 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
566 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
567 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
568 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
569 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
570 // 3. check ret is ERR_DM_FAILED
571 ASSERT_EQ(ret, ERR_DM_FAILED);
572 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
573 }
574
575 /**
576 * @tc.name: UnInitDeviceManager_005
577 * @tc.desc: 1. set packName not null
578 * 2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED
579 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter
580 * 4. check ret is ERR_DM_FAILED
581 * deviceTypeId
582 * @tc.type: FUNC
583 * @tc.require: AR000GHSJK
584 */
585 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_005, testing::ext::TestSize.Level0)
586 {
587 // 1. set packName not null
588 std::string packName = "com.ohos.test";
589 // 2. call DeviceManagerImpl::InitDeviceManager with parameter
590 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
591 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
592 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
593 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
594 // 3. check ret is ERR_DM_FAILED
595 ASSERT_EQ(ret, ERR_DM_FAILED);
596 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
597 }
598
599 /**
600 * @tc.name: GetTrustedDeviceList_001
601 * @tc.desc: 1. set packName null
602 * set extra null
603 * set deviceList null
604 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
605 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
606 * deviceTypeId
607 * @tc.type: FUNC
608 * @tc.require: AR000GHSJK
609 */
610 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0)
611 {
612 // 1. set packName null
613 std::string packName = "";
614 // set extra null
615 std::string extra = "";
616 // set deviceList null
617 std::vector<DmDeviceInfo> deviceList;
618 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
619 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
620 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
621 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
622 }
623
624 /**
625 * @tc.name: GetTrustedDeviceList_002
626 * @tc.desc: 1. set packName not null
627 * set extra null
628 * set deviceList null
629 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
630 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
631 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
632 * deviceTypeId
633 * @tc.type: FUNC
634 * @tc.require: AR000GHSJK
635 */
636 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0)
637 {
638 // 1. set packName not null
639 std::string packName = "com.ohos.test";
640 // set extra null
641 std::string extra = "";
642 // set deviceList null
643 std::vector<DmDeviceInfo> deviceList;
644 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
645 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
646 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
647 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
648 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
649 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
650 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
651 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
652 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
653 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
654 }
655
656 /**
657 * @tc.name: GetTrustedDeviceList_003
658 * @tc.desc: 1. set packName not null
659 * set extra null
660 * set deviceList null
661 * 2. MOCK IpcClientProxy SendRequest return DM_OK
662 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
663 * 4. check ret is DM_OK
664 * deviceTypeId
665 * @tc.type: FUNC
666 * @tc.require: AR000GHSJK
667 */
668 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_003, testing::ext::TestSize.Level0)
669 {
670 // 1. set packName not null
671 std::string packName = "com.ohos.test";
672 // set extra null
673 std::string extra = "";
674 // set deviceList null
675 std::vector<DmDeviceInfo> deviceList;
676 // 2. MOCK IpcClientProxy SendRequest return DM_OK
677 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
678 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
679 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
680 .Times(1).WillOnce(testing::Return(DM_OK));
681 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
682 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
683 // 3. check ret is DM_OK
684 ASSERT_EQ(ret, DM_OK);
685 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
686 }
687
688 /**
689 * @tc.name: GetTrustedDeviceList_004
690 * @tc.desc: 1. set packName not null
691 * set extra null
692 * set deviceList null
693 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
694 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
695 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
696 * deviceTypeId
697 * @tc.type: FUNC
698 * @tc.require: AR000GHSJK
699 */
700 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_004, testing::ext::TestSize.Level0)
701 {
702 // 1. set packName not null
703 std::string packName = "com.ohos.test";
704 // set extra null
705 std::string extra = "test";
706 // set deviceList null
707 std::vector<DmDeviceInfo> deviceList;
708 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
709 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
710 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
711 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
712 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
713 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
714 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
715 // 3. check ret is DEVICEMANAGER_IPC_FAILED
716 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
717 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
718 }
719
720 /**
721 * @tc.name: GetTrustedDeviceList_005
722 * @tc.desc: 1. set packName null
723 * set extra null
724 * set deviceList null
725 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
726 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
727 * deviceTypeId
728 * @tc.type: FUNC
729 * @tc.require: AR000GHSJK
730 */
731 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_005, testing::ext::TestSize.Level0)
732 {
733 // 1. set packName null
734 std::string packName = "";
735 // set extra null
736 std::string extra = "test";
737 // set deviceList null
738 std::vector<DmDeviceInfo> deviceList;
739 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
740 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
741 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
742 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
743 }
744
745 /**
746 * @tc.name: GetLocalDeviceInfo_001
747 * @tc.desc: 1. set packName null
748 * set extra null
749 * set deviceList null
750 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
751 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
752 * deviceTypeId
753 * @tc.type: FUNC
754 * @tc.require: AR000GHSJK
755 */
756 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0)
757 {
758 // 1. set packName not null
759 std::string packName = "com.ohos.test";
760 // set extra null
761 DmDeviceInfo info;
762 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
763 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
764 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
765 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
766 .Times(1).WillOnce(testing::Return(DM_OK));
767 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
768 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
769 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
770 ASSERT_EQ(ret, DM_OK);
771 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
772 }
773
774 /**
775 * @tc.name: GetLocalDeviceInfo_002
776 * @tc.desc: 1. set packName not null
777 * set extra null
778 * set deviceList null
779 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
780 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
781 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
782 * deviceTypeId
783 * @tc.type: FUNC
784 * @tc.require: AR000GHSJK
785 */
786 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_002, testing::ext::TestSize.Level0)
787 {
788 // 1. set packName not null
789 std::string packName = "com.ohos.test";
790 // set extra null
791 DmDeviceInfo info;
792 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
793 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
794 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
795 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
796 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
797 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
798 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
799 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
800 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
801 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
802 }
803
804 /**
805 * @tc.name: GetLocalDeviceInfo_003
806 * @tc.desc: 1. set packName not null
807 * set extra null
808 * set deviceList null
809 * 2. MOCK IpcClientProxy SendRequest return DM_OK
810 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
811 * 4. check ret is DM_OK
812 * deviceTypeId
813 * @tc.type: FUNC
814 * @tc.require: AR000GHSJK
815 */
816 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_003, testing::ext::TestSize.Level0)
817 {
818 // 1. set packName not null
819 std::string packName = "com.ohos.test";
820 // set extra null
821 DmDeviceInfo info;
822 // 2. MOCK IpcClientProxy SendRequest return DM_OK
823 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
824 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
825 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
826 .Times(1).WillOnce(testing::Return(DM_OK));
827 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
828 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
829 // 3. check ret is DM_OK
830 ASSERT_EQ(ret, DM_OK);
831 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
832 }
833
834 /**
835 * @tc.name: GetLocalDeviceInfo_004
836 * @tc.desc: 1. set packName not null
837 * set extra null
838 * set deviceList null
839 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
840 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
841 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
842 * deviceTypeId
843 * @tc.type: FUNC
844 * @tc.require: AR000GHSJK
845 */
846 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_004, testing::ext::TestSize.Level0)
847 {
848 // 1. set packName not null
849 std::string packName = "com.ohos.test";
850 // set extra null
851 DmDeviceInfo info;
852 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
853 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
854 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
855 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
856 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
857 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
858 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
859 // 3. check ret is DEVICEMANAGER_IPC_FAILED
860 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
861 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
862 }
863
864 /**
865 * @tc.name: GetLocalDeviceInfo_005
866 * @tc.desc: 1. set packName null
867 * set extra null
868 * set deviceList null
869 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
870 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
871 * deviceTypeId
872 * @tc.type: FUNC
873 * @tc.require: AR000GHSJK
874 */
875 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_005, testing::ext::TestSize.Level0)
876 {
877 // 1. set packName not null
878 std::string packName = "";
879 // set extra null
880 DmDeviceInfo info;
881 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
882 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
883 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
884 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
885 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
886 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
887 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
888 // 3. check ret is DEVICEMANAGER_IPC_FAILED
889 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
890 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
891 }
892
893 /**
894 * @tc.name: RegisterDevStateCallback_001
895 * @tc.desc: 1. set packName null
896 * set extra null
897 * set callback null
898 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
899 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
900 * deviceTypeId
901 * @tc.type: FUNC
902 * @tc.require: AR000GHSJK
903 */
904 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0)
905 {
906 // 1. set packName null
907 std::string packName = "";
908 // set extra null
909 std::string extra= "";
910 // set callback nullptr
911 std::shared_ptr<DeviceStateCallback> callback = nullptr;
912 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
913 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
914 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
915 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
916 }
917
918 /**
919 * @tc.name: RegisterDevStateCallback_002
920 * @tc.desc: 1. set packName not null
921 * set extra null
922 * set callback not null
923 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
924 * 3. check ret is DM_OK
925 * deviceTypeId
926 * @tc.type: FUNC
927 * @tc.require: AR000GHSJK
928 */
929 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_002, testing::ext::TestSize.Level0)
930 {
931 // 1. set packName null
932 std::string packName = "com.ohos.test";
933 // set extra null
934 std::string extra= "";
935 // set callback not null
936 std::shared_ptr<DeviceStateCallback> callback =std::make_shared<DeviceStateCallbackTest>();
937 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
938 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
939 // 3. check ret is DM_OK
940 ASSERT_EQ(ret, DM_OK);
941 }
942
943 /**
944 * @tc.name: RegisterDevStateCallback_003
945 * @tc.desc: 1. set packName null
946 * set extra not null
947 * set callback null
948 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
949 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
950 * deviceTypeId
951 * @tc.type: FUNC
952 * @tc.require: AR000GHSJK
953 */
954 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_003, testing::ext::TestSize.Level0)
955 {
956 // 1. set packName null
957 std::string pkgName = "";
958 // set extra null
959 std::string extra= "test";
960 // set callback nullptr
961 std::shared_ptr<DeviceStateCallback> callback = nullptr;
962 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
963 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
964 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
965 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
966 }
967
968 /**
969 * @tc.name: RegisterDevStateCallback_004
970 * @tc.desc: 1. set packName not null
971 * set extra not null
972 * set callback not null
973 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
974 * 3. check ret is DM_OK
975 * deviceTypeId
976 * @tc.type: FUNC
977 * @tc.require: AR000GHSJK
978 */
979 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_004, testing::ext::TestSize.Level0)
980 {
981 // 1. set packName null
982 std::string pkgName = "com.ohos.test";
983 // set extra null
984 std::string extra= "test";
985 // set callback nullptr
986 std::shared_ptr<DeviceStateCallback> callback = nullptr;
987 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
988 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
989 // 3. check ret is DM_OK
990 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
991 }
992
993 /**
994 * @tc.name: RegisterDevStateCallback_005
995 * @tc.desc: 1. set packName not null
996 * set extra not null
997 * set callback null
998 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
999 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1000 * deviceTypeId
1001 * @tc.type: FUNC
1002 * @tc.require: AR000GHSJK
1003 */
1004 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_005, testing::ext::TestSize.Level0)
1005 {
1006 // 1. set packName null
1007 std::string pkgName = "com.ohos.test";
1008 // set extra null
1009 std::string extra= "test1";
1010 // set callback nullptr
1011 std::shared_ptr<DeviceStateCallback> callback = nullptr;
1012 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1013 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
1014 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1015 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1016 }
1017
1018 /**
1019 * @tc.name: UnRegisterDevStateCallback_001
1020 * @tc.desc: 1. set packName null
1021 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1022 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1023 * deviceTypeId
1024 * @tc.type: FUNC
1025 * @tc.require: AR000GHSJK
1026 */
1027 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0)
1028 {
1029 // 1. set packName null
1030 std::string packName = "";
1031 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1032 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1033 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1034 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1035 }
1036
1037 /**
1038 * @tc.name: UnRegisterDevStateCallback_002
1039 * @tc.desc: 1. set packName null
1040 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1041 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1042 * deviceTypeId
1043 * @tc.type: FUNC
1044 * @tc.require: AR000GHSJK
1045 */
1046 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_002, testing::ext::TestSize.Level0)
1047 {
1048 // 1. set packName null
1049 std::string packName = "";
1050 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1051 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1052 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1053 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1054 }
1055
1056 /**
1057 * @tc.name: UnRegisterDevStateCallback_003
1058 * @tc.desc: 1. set packName null
1059 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1060 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1061 * deviceTypeId
1062 * @tc.type: FUNC
1063 * @tc.require: AR000GHSJK
1064 */
1065 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_003, testing::ext::TestSize.Level0)
1066 {
1067 // 1. set packName null
1068 std::string packName = "";
1069 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1070 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1071 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1072 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1073 }
1074
1075 /**
1076 * @tc.name: UnRegisterDevStateCallback_004
1077 * @tc.desc: 1. set packName null
1078 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1079 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1080 * deviceTypeId
1081 * @tc.type: FUNC
1082 * @tc.require: AR000GHSJK
1083 */
1084 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_004, testing::ext::TestSize.Level0)
1085 {
1086 // 1. set packName null
1087 std::string packName = "";
1088 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1089 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1090 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1091 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1092 }
1093
1094 /**
1095 * @tc.name: UnRegisterDevStateCallback_005
1096 * @tc.desc: 1. set packName null
1097 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
1098 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1099 * deviceTypeId
1100 * @tc.type: FUNC
1101 * @tc.require: AR000GHSJK
1102 */
1103 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_005, testing::ext::TestSize.Level0)
1104 {
1105 // 1. set packName null
1106 std::string packName = "";
1107 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1108 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
1109 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1110 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1111 }
1112
1113 /**
1114 * @tc.name: StartDeviceDiscovery_001
1115 * @tc.desc: 1. set packName null
1116 * set subscribeInfo null
1117 * set callback null
1118 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1119 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1120 * deviceTypeId
1121 * @tc.type: FUNC
1122 * @tc.require: AR000GHSJK
1123 */
1124 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
1125 {
1126 // 1. set packName null
1127 std::string packName = "";
1128 // set subscribeInfo null
1129 std::string extra = "test";
1130 DmSubscribeInfo subscribeInfo;
1131 // set callback null
1132 std::shared_ptr<DiscoveryCallback> callback = nullptr;
1133 // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1134 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1135 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1136 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1137 }
1138
1139 /**
1140 * @tc.name: StartDeviceDiscovery_002
1141 * @tc.desc: 1. set packName null
1142 * set subscribeInfo null
1143 * set callback null
1144 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1145 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1146 * deviceTypeId
1147 * @tc.type: FUNC
1148 * @tc.require: AR000GHSJK
1149 */
1150 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
1151 {
1152 // 1. set packName null
1153 std::string packName = "com.ohos.helloworld";
1154 std::string extra = "test";
1155 // set subscribeInfo null
1156 DmSubscribeInfo subscribeInfo;
1157 // set callback null
1158 std::shared_ptr<DiscoveryCallback> callback = nullptr;
1159 // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1160 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1161 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1162 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1163 }
1164
1165 /**
1166 * @tc.name: StartDeviceDiscovery_003
1167 * @tc.desc: 1. set packName null
1168 * set subscribeInfo null
1169 * set callback null
1170 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1171 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
1172 * deviceTypeId
1173 * @tc.type: FUNC
1174 * @tc.require: AR000GHSJK
1175 */
1176 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0)
1177 {
1178 // 1. set packName not null
1179 std::string packName = "com.ohos.test";
1180 // set subscribeInfo is 0
1181 DmSubscribeInfo subscribeInfo;
1182 std::string extra = "test";
1183 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
1184 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1185 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1186 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1187 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1188 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1189 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1190 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1191 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1192 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1193 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1194 }
1195
1196 /**
1197 * @tc.name: StartDeviceDiscovery_004
1198 * @tc.desc: 1. set packName not null
1199 * set subscribeInfo null
1200 * set callback not null
1201 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1202 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1203 * 4. check ret is DM_OK
1204 * deviceTypeId
1205 * @tc.type: FUNC
1206 * @tc.require: AR000GHSJK
1207 */
1208 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0)
1209 {
1210 // 1. set packName not null
1211 std::string packName = "com.ohos.helloworld";
1212 std::string extra= "test";
1213 // set subscribeInfo null
1214 DmSubscribeInfo subscribeInfo;
1215 // set callback not null
1216 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
1217 // 2. MOCK IpcClientProxy SendRequest return DM_OK
1218 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1219 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1220 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1221 .Times(1).WillOnce(testing::Return(DM_OK));
1222 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1223 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1224 // 4. check ret is DM_OK
1225 ASSERT_EQ(ret, DM_OK);
1226 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1227 }
1228
1229 /**
1230 * @tc.name: StartDeviceDiscovery_005
1231 * @tc.desc: 1. set packName not null
1232 * set subscribeInfo null
1233 * set callback not null
1234 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1235 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1236 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1237 * deviceTypeId
1238 * @tc.type: FUNC
1239 * @tc.require: AR000GHSJK
1240 */
1241 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_005, testing::ext::TestSize.Level0)
1242 {
1243 // 1. set packName not null
1244 std::string packName = "com.ohos.helloworld";
1245 std::string extra= "test";
1246 // set subscribeInfo null
1247 DmSubscribeInfo subscribeInfo;
1248 // set callback not null
1249 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
1250 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1251 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1252 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1253 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1254 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1255 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
1256 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
1257 // 4. check ret is DEVICEMANAGER_IPC_FAILED
1258 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1259 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1260 }
1261
1262 /**
1263 * @tc.name: StopDeviceDiscovery_001
1264 * @tc.desc: 1. set packName null
1265 * set subscribeId is 0
1266 * 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1267 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1268 * deviceTypeId
1269 * @tc.type: FUNC
1270 * @tc.require: AR000GHSJK
1271 */
1272 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0)
1273 {
1274 // 1. set packName null
1275 std::string packName = "";
1276 // set subscribeInfo is 0
1277 uint16_t subscribeId = 0;
1278 // 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1279 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
1280 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1281 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1282 }
1283
1284 /**
1285 * @tc.name: StopDeviceDiscovery_002
1286 * @tc.desc: 1. set packName not null
1287 * set subscribeId is 0
1288 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1289 * 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1290 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1291 * deviceTypeId
1292 * @tc.type: FUNC
1293 * @tc.require: AR000GHSJK
1294 */
1295 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0)
1296 {
1297 // 1. set packName not null
1298 std::string packName = "com.ohos.test";
1299 // set subscribeInfo is 0
1300 uint16_t subscribeId = 0;
1301 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1302 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1303 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1304 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1305 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1306 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1307 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
1308 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1309 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1310 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1311 }
1312
1313 /**
1314 * @tc.name: StopDeviceDiscovery_003
1315 * @tc.desc: 1. set packName not null
1316 * set subscribeId is 0
1317 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1318 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1319 * 4. check ret is DM_OK
1320 * deviceTypeId
1321 * @tc.type: FUNC
1322 * @tc.require: AR000GHSJK
1323 */
1324 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_003, testing::ext::TestSize.Level0)
1325 {
1326 // 1. set packName not null
1327 std::string packName = "com.ohos.test";
1328 // set subscribeInfo is 0
1329 uint16_t subscribeId = 0;
1330 // 2. MOCK IpcClientProxy SendRequest return DM_OK
1331 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1332 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1333 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1334 .Times(1).WillOnce(testing::Return(DM_OK));
1335 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1336 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
1337 // 4. check ret is DM_OK
1338 ASSERT_EQ(ret, DM_OK);
1339 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1340 }
1341
1342 /**
1343 * @tc.name: StopDeviceDiscovery_004
1344 * @tc.desc: 1. set packName not null
1345 * set subscribeId is 0
1346 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1347 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1348 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1349 * deviceTypeId
1350 * @tc.type: FUNC
1351 * @tc.require: AR000GHSJK
1352 */
1353 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_004, testing::ext::TestSize.Level0)
1354 {
1355 // 1. set packName not null
1356 std::string packName = "com.ohos.test";
1357 // set subscribeInfo is 0
1358 uint16_t subscribeId = 0;
1359 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1360 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1361 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1362 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1363 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1364 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1365 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
1366 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1367 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1368 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1369 }
1370
1371 /**
1372 * @tc.name: StopDeviceDiscovery_005
1373 * @tc.desc: 1. set packName not null
1374 * set subscribeId is 0
1375 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1376 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1377 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1378 * deviceTypeId
1379 * @tc.type: FUNC
1380 * @tc.require: AR000GHSJK
1381 */
1382 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_005, testing::ext::TestSize.Level0)
1383 {
1384 // 1. set packName not null
1385 std::string packName = "com.ohos.test";
1386 // set subscribeInfo is 0
1387 uint16_t subscribeId = 0;
1388 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1389 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1390 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1391 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1392 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
1393 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1394 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
1395 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1396 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1397 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1398 }
1399
1400 /**
1401 * @tc.name: PublishDeviceDiscovery_001
1402 * @tc.desc: 1. set packName null
1403 * set subscribeInfo null
1404 * set callback null
1405 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1406 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1407 * deviceTypeId
1408 * @tc.type: FUNC
1409 * @tc.require: I5N1K3
1410 */
1411 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
1412 {
1413 // 1. set packName null
1414 std::string packName = "";
1415 // set publishInfo null
1416 DmPublishInfo publishInfo;
1417 // set callback null
1418 std::shared_ptr<PublishCallback> callback = nullptr;
1419 // 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1420 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
1421 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1422 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1423 }
1424
1425 /**
1426 * @tc.name: PublishDeviceDiscovery_002
1427 * @tc.desc: 1. set packName null
1428 * set subscribeInfo null
1429 * set callback null
1430 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1431 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1432 * deviceTypeId
1433 * @tc.type: FUNC
1434 * @tc.require: I5N1K3
1435 */
1436 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
1437 {
1438 // 1. set packName null
1439 std::string packName = "com.ohos.helloworld";
1440 // set publishInfo null
1441 DmPublishInfo publishInfo;
1442 // set callback null
1443 std::shared_ptr<PublishCallback> callback = nullptr;
1444 // 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1445 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
1446 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1447 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1448 }
1449
1450 /**
1451 * @tc.name: PublishDeviceDiscovery_003
1452 * @tc.desc: 1. set packName null
1453 * set publishInfo null
1454 * set callback null
1455 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1456 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
1457 * deviceTypeId
1458 * @tc.type: FUNC
1459 * @tc.require: I5N1K3
1460 */
1461 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
1462 {
1463 // 1. set packName not null
1464 std::string packName = "com.ohos.test";
1465 // set publishInfo is 0
1466 DmPublishInfo publishInfo;
1467 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
1468 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1469 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1470 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1471 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1472 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1473 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1474 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
1475 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1476 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1477 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1478 }
1479
1480 /**
1481 * @tc.name: PublishDeviceDiscovery_004
1482 * @tc.desc: 1. set packName not null
1483 * set publishInfo null
1484 * set callback not null
1485 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1486 * 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1487 * 4. check ret is DM_OK
1488 * deviceTypeId
1489 * @tc.type: FUNC
1490 * @tc.require: I5N1K3
1491 */
1492 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_004, testing::ext::TestSize.Level0)
1493 {
1494 // 1. set packName not null
1495 std::string packName = "com.ohos.helloworld";
1496 // set publishInfo null
1497 DmPublishInfo publishInfo;
1498 // set callback not null
1499 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
1500 // 2. MOCK IpcClientProxy SendRequest return DM_OK
1501 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1502 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1503 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1504 .Times(1).WillOnce(testing::Return(DM_OK));
1505 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1506 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
1507 // 4. check ret is DM_OK
1508 ASSERT_EQ(ret, DM_OK);
1509 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1510 }
1511
1512 /**
1513 * @tc.name:PublishDeviceDiscovery_005
1514 * @tc.desc: 1. set packName not null
1515 * set subscribeInfo null
1516 * set callback not null
1517 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1518 * 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1519 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1520 * deviceTypeId
1521 * @tc.type: FUNC
1522 * @tc.require: I5N1K3
1523 */
1524 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_005, testing::ext::TestSize.Level0)
1525 {
1526 // 1. set packName not null
1527 std::string packName = "com.ohos.helloworld";
1528 // set publishInfo null
1529 DmPublishInfo publishInfo;
1530 // set callback not null
1531 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
1532 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1533 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1534 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1535 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1536 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1537 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
1538 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
1539 // 4. check ret is DEVICEMANAGER_IPC_FAILED
1540 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1541 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1542 }
1543
1544 /**
1545 * @tc.name: UnPublishDeviceDiscovery_001
1546 * @tc.desc: 1. set packName null
1547 * set publishId is 0
1548 * 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1549 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
1550 * deviceTypeId
1551 * @tc.type: FUNC
1552 * @tc.require: I5N1K3
1553 */
1554 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
1555 {
1556 // 1. set packName null
1557 std::string packName = "";
1558 // set publishId is 0
1559 int32_t publishId = 0;
1560 // 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1561 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
1562 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1563 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1564 }
1565
1566 /**
1567 * @tc.name: UnPublishDeviceDiscovery_002
1568 * @tc.desc: 1. set packName not null
1569 * set publishId is 0
1570 * 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1571 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1572 * deviceTypeId
1573 * @tc.type: FUNC
1574 * @tc.require: I5N1K3
1575 */
1576 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
1577 {
1578 // 1. set packName not null
1579 std::string packName = "com.ohos.test";
1580 // set subscribeInfo is 0
1581 int32_t publishId = 0;
1582 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1583 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1584 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1585 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1586 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1587 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1588 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
1589 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1590 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1591 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1592 }
1593
1594 /**
1595 * @tc.name: UnPublishDeviceDiscovery_003
1596 * @tc.desc: 1. set packName not null
1597 * set publishId is 0
1598 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1599 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1600 * 4. check ret is DM_OK
1601 * deviceTypeId
1602 * @tc.type: FUNC
1603 * @tc.require: I5N1K3
1604 */
1605 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
1606 {
1607 // 1. set packName not null
1608 std::string packName = "com.ohos.test";
1609 // set subscribeInfo is 0
1610 int32_t publishId = 0;
1611 // 2. MOCK IpcClientProxy SendRequest return DM_OK
1612 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1613 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1614 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1615 .Times(1).WillOnce(testing::Return(DM_OK));
1616 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1617 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
1618 // 4. check ret is DM_OK
1619 ASSERT_EQ(ret, DM_OK);
1620 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1621 }
1622
1623 /**
1624 * @tc.name: UnPublishDeviceDiscovery_004
1625 * @tc.desc: 1. set packName not null
1626 * set publishId is 0
1627 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1628 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1629 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1630 * deviceTypeId
1631 * @tc.type: FUNC
1632 * @tc.require: I5N1K3
1633 */
1634 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_004, testing::ext::TestSize.Level0)
1635 {
1636 // 1. set packName not null
1637 std::string packName = "com.ohos.test";
1638 // set publishId is 0
1639 int32_t publishId = 0;
1640 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1641 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1642 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1643 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1644 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1645 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1646 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
1647 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1648 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1649 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1650 }
1651
1652 /**
1653 * @tc.name: UnPublishDeviceDiscovery_005
1654 * @tc.desc: 1. set packName not null
1655 * set publishId is 0
1656 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1657 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
1658 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1659 * deviceTypeId
1660 * @tc.type: FUNC
1661 * @tc.require: I5N1K3
1662 */
1663 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_005, testing::ext::TestSize.Level0)
1664 {
1665 // 1. set packName not null
1666 std::string packName = "com.ohos.test";
1667 // set publishId is 0
1668 int32_t publishId = 0;
1669 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1670 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1671 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1672 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1673 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
1674 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
1675 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
1676 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1677 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1678 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1679 }
1680
1681 /**
1682 * @tc.name: AuthenticateDevice_001
1683 * @tc.desc: 1. set packName = null
1684 * set dmDeviceInfo = null
1685 * set dmAppImageInfo = null
1686 * set extra = null
1687 * set callback = nullptr
1688 * 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1689 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
1690 * deviceTypeId
1691 * @tc.type: FUNC
1692 * @tc.require: AR000GHSJK
1693 */
1694 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
1695 {
1696 // 1. set packName = null
1697 std::string packName = "";
1698 int32_t authType = 1;
1699 // set dmDeviceInfo = null
1700 DmDeviceInfo dmDeviceInfo;
1701 // set extra = null
1702 std::string extra= "";
1703 // set callback = nullptr
1704 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1705 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1706 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
1707 // 3. check ret is DEVICEMANAGER_INVALID_VALUE
1708 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1709 }
1710
1711 /**
1712 * @tc.name: AuthenticateDevice_002
1713 * @tc.desc: 1. set packName not null
1714 * set dmDeviceInfo null
1715 * set dmAppImageInfo null
1716 * set extra null
1717 * set callback null
1718 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1719 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1720 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1721 * deviceTypeId
1722 * @tc.type: FUNC
1723 * @tc.require: AR000GHSJK
1724 */
1725 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
1726 {
1727 // 1. set packName not null
1728 std::string packName = "com.ohos.helloworld";
1729 int32_t authType = 1;
1730 // set dmDeviceInfo null
1731 DmDeviceInfo dmDeviceInfo;
1732 // set extra null
1733 std::string extra = "";
1734 // set callback null
1735 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1736 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1737 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1738 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1739 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1740 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1741 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1742 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
1743 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1744 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1745 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1746 }
1747
1748 /**
1749 * @tc.name: AuthenticateDevice_003
1750 * @tc.desc: 1. set packName not null
1751 * set dmDeviceInfo null
1752 * set dmAppImageInfo null
1753 * set extra null
1754 * set callback null
1755 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1756 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1757 * 4. check ret is DM_OK
1758 * deviceTypeId
1759 * @tc.type: FUNC
1760 * @tc.require: AR000GHSJK
1761 */
1762 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
1763 {
1764 // 1. set packName not null
1765 std::string packName = "com.ohos.helloworld";
1766 // set dmDeviceInfo null
1767 int32_t authType = 1;
1768 // set dmAppImageInfo null
1769 DmDeviceInfo dmDeviceInfo;
1770 // set extra null
1771 std::string extra = "";
1772 // set callback null
1773 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1774 // 2. MOCK IpcClientProxy SendRequest return DM_OK
1775 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1776 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1777 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1778 .Times(1).WillOnce(testing::Return(DM_OK));
1779 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1780 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
1781 // 4. check ret is DM_OK
1782 ASSERT_EQ(ret, DM_OK);
1783 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1784 }
1785
1786 /**
1787 * @tc.name: AuthenticateDevice_004
1788 * @tc.desc: 1. set packName not null
1789 * set dmDeviceInfo null
1790 * set dmAppImageInfo null
1791 * set extra null
1792 * set callback null
1793 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1794 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1795 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1796 * deviceTypeId
1797 * @tc.type: FUNC
1798 * @tc.require: AR000GHSJK
1799 */
1800 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_004, testing::ext::TestSize.Level0)
1801 {
1802 // 1. set packName not null
1803 std::string packName = "com.ohos.helloworld";
1804 // set dmDeviceInfo null
1805 int32_t authType = 1;
1806 // set dmAppImageInfo null
1807 DmDeviceInfo dmDeviceInfo;
1808 // set extra null
1809 std::string extra = "";
1810 // set callback null
1811 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1812 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1813 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1814 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1815 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1816 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1817 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1818 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
1819 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1820 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1821 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1822 }
1823
1824 /**
1825 * @tc.name: AuthenticateDevice_005
1826 * @tc.desc: 1. set packName not null
1827 * set dmDeviceInfo null
1828 * set dmAppImageInfo null
1829 * set extra null
1830 * set callback null
1831 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1832 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1833 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1834 * deviceTypeId
1835 * @tc.type: FUNC
1836 * @tc.require: AR000GHSJK
1837 */
1838 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_005, testing::ext::TestSize.Level0)
1839 {
1840 // 1. set packName not null
1841 std::string packName = "com.ohos.helloworld";
1842 // set dmDeviceInfo null
1843 int32_t authType = 1;
1844 // set dmAppImageInfo null
1845 DmDeviceInfo dmDeviceInfo;
1846 // set extra null
1847 std::string extra = "";
1848 // set callback null
1849 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1850 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1851 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1852 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1853 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1854 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
1855 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1856 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
1857 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1858 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1859 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1860 }
1861
1862 /**
1863 * @tc.name: UnAuthenticateDevice_001
1864 * @tc.desc: 1. set packName = null
1865 * set dmDeviceInfo = null
1866 * set dmAppImageInfo = null
1867 * set extra = null
1868 * set callback = nullptr
1869 * 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1870 * 3. check ret is DEVICEMANAGER_INVALID_VALUE
1871 * deviceTypeId
1872 * @tc.type: FUNC
1873 * @tc.require: AR000GHSJK
1874 */
1875 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
1876 {
1877 // 1. set packName = null
1878 std::string packName = "";
1879 DmDeviceInfo deviceInfo;
1880 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1881 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
1882 // 3. check ret is DEVICEMANAGER_INVALID_VALUE
1883 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1884 }
1885
1886 /**
1887 * @tc.name: UnAuthenticateDevice_002
1888 * @tc.desc: 1. set packName not null
1889 * set dmDeviceInfo null
1890 * set dmAppImageInfo null
1891 * set extra null
1892 * set callback null
1893 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1894 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1895 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1896 * deviceTypeId
1897 * @tc.type: FUNC
1898 * @tc.require: AR000GHSJK
1899 */
1900 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
1901 {
1902 // 1. set packName = null
1903 std::string packName = "com.ohos.helloworld";
1904 DmDeviceInfo deviceInfo;
1905 deviceInfo.deviceId[0] = '\0';
1906 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
1907 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
1908 // 3. check ret is DEVICEMANAGER_INVALID_VALUE
1909 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1910 }
1911
1912 /**
1913 * @tc.name: UnAuthenticateDevice_003
1914 * @tc.desc: 1. set packName not null
1915 * set dmDeviceInfo null
1916 * set dmAppImageInfo null
1917 * set extra null
1918 * set callback null
1919 * 2. MOCK IpcClientProxy SendRequest return DM_OK
1920 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1921 * 4. check ret is DM_OK
1922 * deviceTypeId
1923 * @tc.type: FUNC
1924 * @tc.require: AR000GHSJK
1925 */
1926 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
1927 {
1928 // 1. set packName not null
1929 std::string packName = "com.ohos.helloworld";
1930 DmDeviceInfo deviceInfo;
1931 deviceInfo.deviceId[0] = '1';
1932 deviceInfo.deviceId[1] = '2';
1933 deviceInfo.deviceId[2] = '\0';
1934 // set callback null
1935 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1936 // 2. MOCK IpcClientProxy SendRequest return DM_OK
1937 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1938 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1939 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1940 .Times(1).WillOnce(testing::Return(DM_OK));
1941 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1942 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
1943 // 4. check ret is DM_OK
1944 ASSERT_EQ(ret, DM_OK);
1945 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1946 }
1947
1948 /**
1949 * @tc.name: UnAuthenticateDevice_004
1950 * @tc.desc: 1. set packName not null
1951 * set dmDeviceInfo null
1952 * set dmAppImageInfo null
1953 * set extra null
1954 * set callback null
1955 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1956 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1957 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1958 * deviceTypeId
1959 * @tc.type: FUNC
1960 * @tc.require: AR000GHSJK
1961 */
1962 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0)
1963 {
1964 // 1. set packName not null
1965 std::string packName = "com.ohos.helloworld";
1966 // set dmDeviceInfo null
1967 DmDeviceInfo deviceInfo;
1968 deviceInfo.deviceId[0] = '1';
1969 deviceInfo.deviceId[1] = '2';
1970 deviceInfo.deviceId[2] = '\0';
1971 std::shared_ptr<AuthenticateCallback> callback = nullptr;
1972 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1973 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1974 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1975 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1976 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1977 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1978 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
1979 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1980 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1981 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1982 }
1983
1984 /**
1985 * @tc.name: UnAuthenticateDevice_005
1986 * @tc.desc: 1. set packName not null
1987 * set dmDeviceInfo null
1988 * set dmAppImageInfo null
1989 * set extra null
1990 * set callback null
1991 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1992 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1993 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1994 * deviceTypeId
1995 * @tc.type: FUNC
1996 * @tc.require: AR000GHSJK
1997 */
1998 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_005, testing::ext::TestSize.Level0)
1999 {
2000 // 1. set packName not null
2001 std::string packName = "com.ohos.helloworld";
2002 // set dmDeviceInfo null
2003 DmDeviceInfo deviceInfo;
2004 deviceInfo.deviceId[0] = '1';
2005 deviceInfo.deviceId[1] = '2';
2006 deviceInfo.deviceId[2] = '\0';
2007 std::shared_ptr<AuthenticateCallback> callback = nullptr;
2008 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2009 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2010 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2011 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2012 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2013 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2014 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
2015 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2016 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2017 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2018 }
2019
2020 /**
2021 * @tc.name: GetFaParam_001
2022 * @tc.desc: 1. set packName = null
2023 * set dmDeviceInfo = null
2024 * set dmAppImageInfo = null
2025 * set extra = null
2026 * set callback = nullptr
2027 * 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2028 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2029 * deviceTypeId
2030 * @tc.type: FUNC
2031 * @tc.require: AR000GHSJK
2032 */
2033 HWTEST_F(DeviceManagerImplTest, GetFaParam_001, testing::ext::TestSize.Level0)
2034 {
2035 // 1. set packName = null
2036 std::string packName = "";
2037 DmAuthParam dmFaParam;
2038 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2039 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2040 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2041 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2042 }
2043
2044 /**
2045 * @tc.name: GetFaParam_002
2046 * @tc.desc: 1. set packName not null
2047 * set dmDeviceInfo null
2048 * set dmAppImageInfo null
2049 * set extra null
2050 * set callback null
2051 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2052 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2053 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2054 * deviceTypeId
2055 * @tc.type: FUNC
2056 * @tc.require: AR000GHSJK
2057 */
2058 HWTEST_F(DeviceManagerImplTest, GetFaParam_002, testing::ext::TestSize.Level0)
2059 {
2060 // 1. set packName not null
2061 std::string packName = "com.ohos.helloworld";
2062 // set callback null
2063 DmAuthParam dmFaParam;
2064 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2065 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2066 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2067 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2068 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2069 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2070 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2071 // 4. check ret is DM_OK
2072 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2073 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2074 }
2075
2076 /**
2077 * @tc.name: GetFaParam_003
2078 * @tc.desc: 1. set packName not null
2079 * set dmDeviceInfo null
2080 * set dmAppImageInfo null
2081 * set extra null
2082 * set callback null
2083 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2084 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2085 * 4. check ret is DM_OK
2086 * deviceTypeId
2087 * @tc.type: FUNC
2088 * @tc.require: AR000GHSJK
2089 */
2090 HWTEST_F(DeviceManagerImplTest, GetFaParam_003, testing::ext::TestSize.Level0)
2091 {
2092 // 1. set packName not null
2093 std::string packName = "com.ohos.helloworld";
2094 // set callback null
2095 DmAuthParam dmFaParam;
2096 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2097 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2098 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2099 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2100 .Times(1).WillOnce(testing::Return(DM_OK));
2101 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2102 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2103 // 4. check ret is DM_OK
2104 ASSERT_EQ(ret, DM_OK);
2105 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2106 }
2107
2108 /**
2109 * @tc.name: GetFaParam_004
2110 * @tc.desc: 1. set packName not null
2111 * set dmDeviceInfo null
2112 * set dmAppImageInfo null
2113 * set extra null
2114 * set callback null
2115 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2116 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2117 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2118 * deviceTypeId
2119 * @tc.type: FUNC
2120 * @tc.require: AR000GHSJK
2121 */
2122 HWTEST_F(DeviceManagerImplTest, GetFaParam_004, testing::ext::TestSize.Level0)
2123 {
2124 // 1. set packName not null
2125 std::string packName = "com.ohos.helloworld";
2126 // set dmDeviceInfo null
2127 DmAuthParam dmFaParam;
2128 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2129 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2130 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2131 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2132 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2133 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2134 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2135 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2136 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2137 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2138 }
2139
2140 /**
2141 * @tc.name: GetFaParam_005
2142 * @tc.desc: 1. set packName not null
2143 * set dmDeviceInfo null
2144 * set dmAppImageInfo null
2145 * set extra null
2146 * set callback null
2147 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2148 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2149 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2150 * deviceTypeId
2151 * @tc.type: FUNC
2152 * @tc.require: AR000GHSJK
2153 */
2154 HWTEST_F(DeviceManagerImplTest, GetFaParam_005, testing::ext::TestSize.Level0)
2155 {
2156 // 1. set packName not null
2157 std::string packName = "com.ohos.helloworld";
2158 // set dmDeviceInfo null
2159 DmAuthParam dmFaParam;
2160 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2161 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2162 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2163 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2164 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2165 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
2166 int32_t ret = DeviceManager::GetInstance().GetFaParam(packName, dmFaParam);
2167 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2168 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2169 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2170 }
2171
2172 /**
2173 * @tc.name: SetUserOperation_001
2174 * @tc.desc: 1. set packName null
2175 * set action null
2176 * 2. call DeviceManagerImpl::SetUserOperation with parameter
2177 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2178 * deviceTypeId
2179 * @tc.type: FUNC
2180 * @tc.require: AR000GHSJK
2181 */
2182 HWTEST_F(DeviceManagerImplTest, SetUserOperation_001, testing::ext::TestSize.Level0)
2183 {
2184 // 1. set packName null
2185 std::string packName = "";
2186 // set authParam null
2187 int32_t action = 0;
2188 const std::string param = "extra";
2189 // 2. call DeviceManagerImpl::SetUserOperation with parameter
2190 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
2191 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2192 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2193 }
2194
2195 /**
2196 * @tc.name: SetUserOperation_002
2197 * @tc.desc: 1. set packName not null
2198 * set action null
2199 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2200 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2201 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2202 * deviceTypeId
2203 * @tc.type: FUNC
2204 * @tc.require: AR000GHSJK
2205 */
2206 HWTEST_F(DeviceManagerImplTest, SetUserOperation_002, testing::ext::TestSize.Level0)
2207 {
2208 // 1. set packName null
2209 std::string packName = "com.ohos.test";
2210 // set authParam null
2211 int32_t action = 0;
2212 const std::string param = "extra";
2213 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2214 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2215 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2216 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2217 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2218 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2219 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
2220 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2221 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2222 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2223 }
2224
2225 /**
2226 * @tc.name: SetUserOperation_003
2227 * @tc.desc: 1. set packName not null
2228 * set action null
2229 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2230 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2231 * 4. check ret is DM_OK
2232 * deviceTypeId
2233 * @tc.type: FUNC
2234 * @tc.require: AR000GHSJK
2235 */
2236 HWTEST_F(DeviceManagerImplTest, SetUserOperation_003, testing::ext::TestSize.Level0)
2237 {
2238 // 1. set packName not null
2239 std::string packName = "com.ohos.test";
2240 // set authParam null
2241 int32_t action = 0;
2242 const std::string param = "extra";
2243 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2244 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2245 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2246 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2247 .Times(1).WillOnce(testing::Return(DM_OK));
2248 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2249 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
2250 // 4. check ret is DM_OK
2251 ASSERT_EQ(ret, DM_OK);
2252 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2253 }
2254
2255 /**
2256 * @tc.name: SetUserOperation_004
2257 * @tc.desc: 1. set packName not null
2258 * set action null
2259 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2260 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2261 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2262 * deviceTypeId
2263 * @tc.type: FUNC
2264 * @tc.require: AR000GHSJK
2265 */
2266 HWTEST_F(DeviceManagerImplTest, SetUserOperation_004, testing::ext::TestSize.Level0)
2267 {
2268 // 1. set packName null
2269 std::string packName = "com.ohos.test";
2270 // set authParam null
2271 int32_t action = 0;
2272 const std::string param = "extra";
2273 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2274 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2275 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2276 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2277 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2278 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2279 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
2280 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2281 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2282 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2283 }
2284
2285 /**
2286 * @tc.name: SetUserOperation_005
2287 * @tc.desc: 1. set packName not null
2288 * set action null
2289 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2290 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2291 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2292 * deviceTypeId
2293 * @tc.type: FUNC
2294 * @tc.require: AR000GHSJK
2295 */
2296 HWTEST_F(DeviceManagerImplTest, SetUserOperation_005, testing::ext::TestSize.Level0)
2297 {
2298 // 1. set packName null
2299 std::string packName = "com.ohos.test";
2300 // set authParam null
2301 int32_t action = 0;
2302 const std::string param = "extra";
2303 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2304 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2305 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2306 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2307 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2308 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2309 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
2310 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2311 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2312 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2313 }
2314
2315 /**
2316 * @tc.name: GetUdidByNetworkId_001
2317 * @tc.desc: 1. set packName null
2318 * set action null
2319 * 2. call DeviceManagerImpl::SetUserOperation with parameter
2320 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2321 * deviceTypeId
2322 * @tc.type: FUNC
2323 * @tc.require: AR000GHSJK
2324 */
2325 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0)
2326 {
2327 // 1. set packName null
2328 std::string packName = "";
2329 // set authParam null
2330 std::string netWorkId = "111";
2331 std::string udid = "222";
2332 // 2. call DeviceManagerImpl::SetUserOperation with parameter
2333 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
2334 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2335 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2336 }
2337
2338 /**
2339 * @tc.name: GetUdidByNetworkId_002
2340 * @tc.desc: 1. set packName not null
2341 * set action null
2342 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2343 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2344 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2345 * deviceTypeId
2346 * @tc.type: FUNC
2347 * @tc.require: AR000GHSJK
2348 */
2349 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0)
2350 {
2351 // 1. set packName null
2352 std::string packName = "com.ohos.test";
2353 // set authParam null
2354 std::string netWorkId = "111";
2355 std::string udid = "222";
2356 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2357 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2358 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2359 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2360 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2361 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2362 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
2363 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2364 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2365 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2366 }
2367
2368 /**
2369 * @tc.name: GetUdidByNetworkId_003
2370 * @tc.desc: 1. set packName not null
2371 * set action null
2372 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2373 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2374 * 4. check ret is DM_OK
2375 * deviceTypeId
2376 * @tc.type: FUNC
2377 * @tc.require: AR000GHSJK
2378 */
2379 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0)
2380 {
2381 // 1. set packName not null
2382 std::string packName = "com.ohos.test";
2383 // set authParam null
2384 std::string netWorkId = "111";
2385 std::string udid = "222";
2386 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2387 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2388 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2389 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2390 .Times(1).WillOnce(testing::Return(DM_OK));
2391 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2392 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
2393 // 4. check ret is DM_OK
2394 ASSERT_EQ(ret, DM_OK);
2395 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2396 }
2397
2398 /**
2399 * @tc.name: GetUdidByNetworkId_004
2400 * @tc.desc: 1. set packName not null
2401 * set action null
2402 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2403 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2404 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2405 * deviceTypeId
2406 * @tc.type: FUNC
2407 * @tc.require: AR000GHSJK
2408 */
2409 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_004, testing::ext::TestSize.Level0)
2410 {
2411 // 1. set packName null
2412 std::string packName = "com.ohos.test";
2413 // set authParam null
2414 std::string netWorkId = "111";
2415 std::string udid = "222";
2416 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2417 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2418 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2419 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2420 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2421 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2422 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
2423 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2424 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2425 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2426 }
2427
2428 /**
2429 * @tc.name: GetUdidByNetworkId_005
2430 * @tc.desc: 1. set packName not null
2431 * set action null
2432 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2433 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2434 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2435 * deviceTypeId
2436 * @tc.type: FUNC
2437 * @tc.require: AR000GHSJK
2438 */
2439 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_005, testing::ext::TestSize.Level0)
2440 {
2441 // 1. set packName null
2442 std::string packName = "com.ohos.test";
2443 // set authParam null
2444 std::string netWorkId = "111";
2445 std::string udid = "222";
2446 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2447 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2448 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2449 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2450 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2451 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2452 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
2453 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2454 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2455 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2456 }
2457
2458 /**
2459 * @tc.name: GetUuidByNetworkId_001
2460 * @tc.desc: 1. set packName null
2461 * set action null
2462 * 2. call DeviceManagerImpl::SetUserOperation with parameter
2463 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2464 * deviceTypeId
2465 * @tc.type: FUNC
2466 * @tc.require: AR000GHSJK
2467 */
2468 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)
2469 {
2470 // 1. set packName null
2471 std::string packName = "";
2472 // set authParam null
2473 std::string netWorkId = "111";
2474 std::string uuid = "222";
2475 // 2. call DeviceManagerImpl::SetUserOperation with parameter
2476 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
2477 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2478 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2479 }
2480
2481 /**
2482 * @tc.name: GetUuidByNetworkId_002
2483 * @tc.desc: 1. set packName not null
2484 * set action null
2485 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2486 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2487 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2488 * deviceTypeId
2489 * @tc.type: FUNC
2490 * @tc.require: AR000GHSJK
2491 */
2492 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0)
2493 {
2494 // 1. set packName null
2495 std::string packName = "com.ohos.test";
2496 // set authParam null
2497 std::string netWorkId = "111";
2498 std::string uuid = "222";
2499 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2500 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2501 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2502 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2503 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2504 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2505 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
2506 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2507 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2508 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2509 }
2510
2511 /**
2512 * @tc.name: GetUuidByNetworkId_003
2513 * @tc.desc: 1. set packName not null
2514 * set action null
2515 * 2. MOCK IpcClientProxy SendRequest return DM_OK
2516 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2517 * 4. check ret is DM_OK
2518 * deviceTypeId
2519 * @tc.type: FUNC
2520 * @tc.require: AR000GHSJK
2521 */
2522 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0)
2523 {
2524 // 1. set packName not null
2525 std::string packName = "com.ohos.test";
2526 // set authParam null
2527 std::string netWorkId = "111";
2528 std::string uuid = "222";
2529 // 2. MOCK IpcClientProxy SendRequest return DM_OK
2530 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2531 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2532 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2533 .Times(1).WillOnce(testing::Return(DM_OK));
2534 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2535 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
2536 // 4. check ret is DM_OK
2537 ASSERT_EQ(ret, DM_OK);
2538 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2539 }
2540
2541 /**
2542 * @tc.name: GetUuidByNetworkId_004
2543 * @tc.desc: 1. set packName not null
2544 * set action null
2545 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2546 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2547 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2548 * deviceTypeId
2549 * @tc.type: FUNC
2550 * @tc.require: AR000GHSJK
2551 */
2552 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_004, testing::ext::TestSize.Level0)
2553 {
2554 // 1. set packName null
2555 std::string packName = "com.ohos.test";
2556 // set authParam null
2557 std::string netWorkId = "111";
2558 std::string uuid = "222";
2559 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
2560 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2561 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2562 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2563 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2564 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2565 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
2566 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2567 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2568 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2569 }
2570
2571 /**
2572 * @tc.name: GetUuidByNetworkId_005
2573 * @tc.desc: 1. set packName not null
2574 * set action null
2575 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2576 * 3. call DeviceManagerImpl::SetUserOperation 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, GetUuidByNetworkId_005, testing::ext::TestSize.Level0)
2583 {
2584 // 1. set packName null
2585 std::string packName = "com.ohos.test";
2586 // set authParam null
2587 std::string netWorkId = "111";
2588 std::string uuid = "222";
2589 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2590 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2591 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2592 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2593 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
2594 // 3. call DeviceManagerImpl::SetUserOperation with parameter
2595 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
2596 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2597 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2598 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2599 }
2600
2601 /**
2602 * @tc.name: RegisterDeviceManagerFaCallback_001
2603 * @tc.desc: 1. set packName not null
2604 * set action null
2605 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
2606 * 3. call DeviceManagerImpl::SetUserOperation with parameter
2607 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
2608 * deviceTypeId
2609 * @tc.type: FUNC
2610 * @tc.require: AR000GHSJK
2611 */
2612 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)
2613 {
2614 // 1. set packName null
2615 std::string packName = "";
2616 // set callback null
2617 std::shared_ptr<DeviceManagerUiCallback> callback = nullptr;
2618 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2619 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
2620 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2621 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2622 }
2623
2624 /**
2625 * @tc.name: RegisterDeviceManagerFaCallback_002
2626 * @tc.desc: 1. set packName not null
2627 * set callback not null
2628 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2629 * 3. check ret is DM_OK
2630 * deviceTypeId
2631 * @tc.type: FUNC
2632 * @tc.require: AR000GHSJK
2633 */
2634 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)
2635 {
2636 // 1. set packName null
2637 std::string packName = "com.ohos.test";
2638 // set callback null
2639 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
2640 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2641 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
2642 // 3. check ret is DM_OK
2643 ASSERT_EQ(ret, DM_OK);
2644 }
2645
2646 /**
2647 * @tc.name: RegisterDeviceManagerFaCallback_003
2648 * @tc.desc: 1. set packName not null
2649 * set callback not null
2650 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2651 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2652 * deviceTypeId
2653 * @tc.type: FUNC
2654 * @tc.require: AR000GHSJK
2655 */
2656 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)
2657 {
2658 // 1. set packName null
2659 std::string packName = "com.ohos.test";
2660 // set callback null
2661 std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr;
2662 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2663 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
2664 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2665 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2666 }
2667
2668 /**
2669 * @tc.name: RegisterDeviceManagerFaCallback_004
2670 * @tc.desc: 1. set packName not null
2671 * set callback not null
2672 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2673 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2674 * deviceTypeId
2675 * @tc.type: FUNC
2676 * @tc.require: AR000GHSJK
2677 */
2678 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)
2679 {
2680 // 1. set packName null
2681 std::string packName = "";
2682 // set callback null
2683 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
2684 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2685 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
2686 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2687 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2688 }
2689
2690 /**
2691 * @tc.name: RegisterDeviceManagerFaCallback_005
2692 * @tc.desc: 1. set packName not null
2693 * set callback not null
2694 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2695 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2696 * deviceTypeId
2697 * @tc.type: FUNC
2698 * @tc.require: AR000GHSJK
2699 */
2700 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)
2701 {
2702 // 1. set packName null
2703 std::string packName ("");
2704 // set callback null
2705 std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr;
2706 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2707 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
2708 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2709 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2710 }
2711
2712 /**
2713 * @tc.name: UnRegisterDeviceManagerFaCallback_001
2714 * @tc.desc: 1. set packName null
2715 * 2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter
2716 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2717 * deviceTypeId
2718 * @tc.type: FUNC
2719 * @tc.require: AR000GHSJK
2720 */
2721 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)
2722 {
2723 // 1. set packName null
2724 std::string packName = "";
2725 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2726 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName);
2727 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2728 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2729 }
2730
2731 /**
2732 * @tc.name: UnRegisterDeviceManagerFaCallback_002
2733 * @tc.desc: 1. set packName not null
2734 * 2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter
2735 * 3. check ret is DM_OK
2736 * deviceTypeId
2737 * @tc.type: FUNC
2738 * @tc.require: AR000GHSJK
2739 */
2740 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)
2741 {
2742 // 1. set packName null
2743 std::string packName = "com.ohos.test";
2744 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
2745 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName);
2746 // 3. check ret is DM_OK
2747 ASSERT_EQ(ret, DM_OK);
2748 }
2749
2750 /**
2751 * @tc.name: UnRegisterDeviceManagerFaCallback_003
2752 * @tc.desc: 1. set packName not null
2753 * set callback not null
2754 * 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
2755 * 3. check ret is DM_OK
2756 * 4. set checkMap null
2757 * 5. Get checkMap from DeviceManagerNotify
2758 * 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
2759 * 7. Get checkMap from pkgName
2760 * 8. check checkMap null
2761 * deviceTypeId
2762 * @tc.type: FUNC
2763 * @tc.require: AR000GHSJK
2764 */
2765 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)
2766 {
2767 // 1. set pkgName not null
2768 std::string pkgName = "com.ohos.test";
2769 // set callback not null
2770 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
2771 // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
2772 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
2773 // 3. check ret is DM_OK
2774 ASSERT_EQ(ret, DM_OK);
2775 // 4. set checkMap null
2776 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
2777 // 5. Get checkMap from DeviceManagerNotify
2778 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
2779 // 5. check checkMap not null
2780 ASSERT_NE(checkMap, nullptr);
2781 // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
2782 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(pkgName);
2783 // 7. Get checkMap from pkgName
2784 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
2785 // 8 check checkMap null
2786 ASSERT_EQ(checkMap, nullptr);
2787 }
2788
2789 /**
2790 * @tc.name: UnRegisterDeviceManagerFaCallback_004
2791 * @tc.desc: 1. set packName not null
2792 * set callback not null
2793 * 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
2794 * 3. check ret is DM_OK
2795 * 4. set checkMap null
2796 * 5. Get checkMap from DeviceManagerNotify
2797 * 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
2798 * 7. Get checkMap from pkgName
2799 * 8. check checkMap null
2800 * deviceTypeId
2801 * @tc.type: FUNC
2802 * @tc.require: AR000GHSJK
2803 */
2804 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)
2805 {
2806 // 1. set pkgName not null
2807 std::string pkgName = "com.ohos.test";
2808 // set callback not null
2809 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
2810 // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
2811 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
2812 // 3. check ret is DM_OK
2813 ASSERT_EQ(ret, DM_OK);
2814 // 4. set checkMap null
2815 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
2816 // 5. Get checkMap from DeviceManagerNotify
2817 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
2818 // 5. check checkMap not null
2819 ASSERT_NE(checkMap, nullptr);
2820 // 6. set unRegisterPkgNamr different from pkgName
2821 std::string unRegisterPkgName = "com.ohos.test1";
2822 // 7. call DeviceManager UnRegisterDeviceManagerFaCallback with unRegisterPkgName
2823 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName);
2824 // 7. Get checkMap from pkgName
2825 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
2826 // 8 check checkMap not null
2827 ASSERT_NE(checkMap, nullptr);
2828 }
2829
2830 /**
2831 * @tc.name: UnRegisterDeviceManagerFaCallback_005
2832 * @tc.desc: 1. set packName not null
2833 * 2. Set checkMap null
2834 * 3. Get checkMap from DeviceManagerNotify
2835 * 4. check checkMap not null
2836 * 5. Set unRegisterPkgName is different from register pkgName
2837 * 6. call DeviceManager UnRegisterDevStateCallback with parameter
2838 * 7. Get checkMap from DeviceManagerNotify
2839 * 8. check checkMap not null
2840 * deviceTypeId
2841 * @tc.type: FUNC
2842 * @tc.require: AR000GHSJK
2843 */
2844 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)
2845 {
2846 // 1. set pkgName not null
2847 std::string pkgName = "com.ohos.test";
2848 // 2. Set checkMap null
2849 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
2850 // 3. Get checkMap from DeviceManagerNotify
2851 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
2852 // 4. check checkMap not null
2853 ASSERT_NE(checkMap, nullptr);
2854 // 5. Set unRegisterPkgName is different from register pkgName
2855 std::string unRegisterPkgName = "com.ohos.test1";
2856 // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
2857 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName);
2858 // 7. Get checkMap from DeviceManagerNotify
2859 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
2860 // 8. check checkMap not null
2861 ASSERT_NE(checkMap, nullptr);
2862 }
2863
2864 /**
2865 * @tc.name: RegisterDevStateCallback_006
2866 * @tc.desc: 1. set packName null
2867 * set extra null
2868 * set callback null
2869 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2870 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2871 * deviceTypeId
2872 * @tc.type: FUNC
2873 * @tc.require: AR000GHSJK
2874 */
2875 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_006, testing::ext::TestSize.Level0)
2876 {
2877 // 1. set packName null
2878 std::string pkgName = "";
2879 // set extra null
2880 std::string extra= "test";
2881 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2882 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra);
2883 // 3. check ret is ERR_DM_INPUT_PARA_INVALID;
2884 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2885 }
2886
2887 /**
2888 * @tc.name: RegisterDevStateCallback_007
2889 * @tc.desc: 1. set packName not null
2890 * set extra null
2891 * set callback not null
2892 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2893 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2894 * deviceTypeId
2895 * @tc.type: FUNC
2896 * @tc.require: AR000GHSJK
2897 */
2898 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_007, testing::ext::TestSize.Level0)
2899 {
2900 // 1. set packName null
2901 std::string packName = "";
2902 // set extra null
2903 std::string extra= "";
2904 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2905 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra);
2906 // 3. check ret is DM_OK
2907 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2908 }
2909
2910 /**
2911 * @tc.name: RegisterDevStateCallback_008
2912 * @tc.desc: 1. set packName null
2913 * set extra not null
2914 * set callback null
2915 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2916 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2917 * deviceTypeId
2918 * @tc.type: FUNC
2919 * @tc.require: AR000GHSJK
2920 */
2921 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_008, testing::ext::TestSize.Level0)
2922 {
2923 // 1. set packName null
2924 std::string packName = "com.ohos.test";
2925 // set extra null
2926 std::string extra= "test";
2927 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2928 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2929 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2930 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
2931 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2932 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra);
2933 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2934 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2935 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2936 }
2937
2938 /**
2939 * @tc.name: RegisterDevStateCallback_009
2940 * @tc.desc: 1. set packName not null
2941 * set extra not null
2942 * set callback not null
2943 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2944 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2945 * deviceTypeId
2946 * @tc.type: FUNC
2947 * @tc.require: AR000GHSJK
2948 */
2949 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_009, testing::ext::TestSize.Level0)
2950 {
2951 // 1. set packName null
2952 std::string packName = "com.ohos.test";
2953 // set extra null
2954 std::string extra= "test";
2955 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2956 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2957 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2958 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
2959 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2960 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra);
2961 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2962 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2963 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2964 }
2965
2966 /**
2967 * @tc.name: RegisterDevStateCallback_010
2968 * @tc.desc: 1. set packName not null
2969 * set extra not null
2970 * set callback null
2971 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2972 * 3. check ret is DM_OK
2973 * deviceTypeId
2974 * @tc.type: FUNC
2975 * @tc.require: AR000GHSJK
2976 */
2977 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_010, testing::ext::TestSize.Level0)
2978 {
2979 // 1. set packName null
2980 std::string packName = "com.ohos.test";
2981 // set extra null
2982 std::string extra= "test";
2983 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2984 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2985 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2986 .Times(1).WillOnce(testing::Return(DM_OK));
2987 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2988 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra);
2989 // 3. check ret is DM_OK
2990 ASSERT_EQ(ret, DM_OK);
2991 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
2992 }
2993
2994 /**
2995 * @tc.name: UnRegisterDevStateCallback_006
2996 * @tc.desc: 1. set packName null
2997 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2998 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
2999 * deviceTypeId
3000 * @tc.type: FUNC
3001 * @tc.require: AR000GHSJK
3002 */
3003 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_006, testing::ext::TestSize.Level0)
3004 {
3005 // 1. set packName null
3006 std::string packName = "";
3007 // set extra null
3008 std::string extra= "";
3009 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3010 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3011 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3012 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3013 }
3014
3015 /**
3016 * @tc.name: UnRegisterDevStateCallback_007
3017 * @tc.desc: 1. set packName not null
3018 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
3019 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3020 * deviceTypeId
3021 * @tc.type: FUNC
3022 * @tc.require: AR000GHSJK
3023 */
3024 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_007, testing::ext::TestSize.Level0)
3025 {
3026 // 1. set packName null
3027 std::string packName = "";
3028 // set extra null
3029 std::string extra= "test";
3030 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3031 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3032 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
3033 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3034 }
3035
3036 /**
3037 * @tc.name: UnRegisterDevStateCallback_008
3038 * @tc.desc: 1. set packName null
3039 * set extra not null
3040 * set callback null
3041 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3042 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3043 * deviceTypeId
3044 * @tc.type: FUNC
3045 * @tc.require: AR000GHSJK
3046 */
3047 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_008, testing::ext::TestSize.Level0)
3048 {
3049 // 1. set packName null
3050 std::string packName = "com.ohos.test";
3051 // set extra null
3052 std::string extra= "test";
3053 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3054 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3055 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3056 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
3057 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3058 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3059 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3060 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3061 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3062 }
3063
3064 /**
3065 * @tc.name: UnRegisterDevStateCallback_009
3066 * @tc.desc: 1. set packName null
3067 * set extra not null
3068 * set callback null
3069 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3070 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3071 * deviceTypeId
3072 * @tc.type: FUNC
3073 * @tc.require: AR000GHSJK
3074 */
3075 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_009, testing::ext::TestSize.Level0)
3076 {
3077 // 1. set packName null
3078 std::string packName = "com.ohos.test";
3079 // set extra null
3080 std::string extra= "test";
3081 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3082 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3083 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3084 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3085 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3086 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3087 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3088 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3089 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3090 }
3091
3092 /**
3093 * @tc.name: UnRegisterDevStateCallback_010
3094 * @tc.desc: 1. set packName not null
3095 * set extra not null
3096 * set callback null
3097 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
3098 * 3. check ret is DM_OK
3099 * deviceTypeId
3100 * @tc.type: FUNC
3101 * @tc.require: AR000GHSJK
3102 */
3103 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_010, testing::ext::TestSize.Level0)
3104 {
3105 // 1. set packName null
3106 std::string packName = "com.ohos.test";
3107 // set extra null
3108 std::string extra= "test";
3109 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3110 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3111 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3112 .Times(1).WillOnce(testing::Return(DM_OK));
3113 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
3114 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName, extra);
3115 // 3. check ret is DM_OK
3116 ASSERT_EQ(ret, DM_OK);
3117 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3118 }
3119
3120 /**
3121 * @tc.name: RequestCredential_001
3122 * @tc.desc: 1. set packName null
3123 * set reqJsonStr null
3124 * 2. call DeviceManagerImpl::RequestCredential with parameter
3125 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3126 * deviceTypeId
3127 * @tc.type: FUNC
3128 * @tc.require: AR000GHSJK
3129 */
3130 HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
3131 {
3132 std::string packName;
3133 std::string reqJsonStr;
3134 std::string returnJsonStr;
3135 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
3136 returnJsonStr);
3137 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3138 }
3139
3140 /**
3141 * @tc.name: RequestCredential_002
3142 * @tc.desc: 1. set packName not null
3143 * set reqJsonStr not null
3144 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
3145 * 3. call DeviceManagerImpl::RequestCredential with parameter
3146 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3147 * deviceTypeId
3148 * @tc.type: FUNC
3149 * @tc.require: AR000GHSJK
3150 */
3151 HWTEST_F(DeviceManagerImplTest, RequestCredential_002, testing::ext::TestSize.Level0)
3152 {
3153 std::string packName = "com.ohos.test";
3154 std::string reqJsonStr = R"({"version":"1.0.0.1","userId":"123"})";
3155 std::string returnJsonStr;
3156 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3157 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3158 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3159 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
3160 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
3161 returnJsonStr);
3162 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3163 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3164 }
3165
3166 /**
3167 * @tc.name: RequestCredential_003
3168 * @tc.desc: 1. set packName not null
3169 * set reqJsonStr not null
3170 * 2. MOCK IpcClientProxy SendRequest return DM_OK
3171 * 3. call DeviceManagerImpl::RequestCredential with parameter
3172 * 4. check ret is DM_OK
3173 * deviceTypeId
3174 * @tc.type: FUNC
3175 * @tc.require: AR000GHSJK
3176 */
3177 HWTEST_F(DeviceManagerImplTest, RequestCredential_003, testing::ext::TestSize.Level0)
3178 {
3179 std::string packName = "com.ohos.test";
3180 std::string reqJsonStr = R"({"version":"1.0.0.1","userId":"123"})";
3181 std::string returnJsonStr;
3182 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3183 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3184 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3185 .Times(1).WillOnce(testing::Return(DM_OK));
3186 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
3187 returnJsonStr);
3188 ASSERT_EQ(ret, DM_OK);
3189 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3190 }
3191
3192 /**
3193 * @tc.name: RequestCredential_004
3194 * @tc.desc: 1. set packName not null
3195 * set reqJsonStr not null
3196 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3197 * 3. call DeviceManagerImpl::RequestCredential with parameter
3198 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3199 * deviceTypeId
3200 * @tc.type: FUNC
3201 * @tc.require: AR000GHSJK
3202 */
3203 HWTEST_F(DeviceManagerImplTest, RequestCredential_004, testing::ext::TestSize.Level0)
3204 {
3205 std::string packName = "com.ohos.test";
3206 std::string reqJsonStr = R"({"version":"1.0.0.1","userId":"123"})";
3207 std::string returnJsonStr;
3208 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3209 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3210 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3211 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3212 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
3213 returnJsonStr);
3214 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3215 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3216 }
3217
3218 /**
3219 * @tc.name: ImportCredential_001
3220 * @tc.desc: 1. set packName null
3221 * set reqJsonStr null
3222 * 2. call DeviceManagerImpl::ImportCredential with parameter
3223 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3224 * deviceTypeId
3225 * @tc.type: FUNC
3226 * @tc.require: AR000GHSJK
3227 */
3228 HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
3229 {
3230 std::string packName;
3231 std::string credentialInfo;
3232 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
3233 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3234 }
3235
3236 /**
3237 * @tc.name: ImportCredential_002
3238 * @tc.desc: 1. set packName not null
3239 * set credentialInfo not null
3240 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
3241 * 3. call DeviceManagerImpl::ImportCredential with parameter
3242 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3243 * deviceTypeId
3244 * @tc.type: FUNC
3245 * @tc.require: AR000GHSJK
3246 */
3247 HWTEST_F(DeviceManagerImplTest, ImportCredential_002, testing::ext::TestSize.Level0)
3248 {
3249 std::string packName = "com.ohos.test";
3250 std::string credentialInfo = R"({"processType":1,"authType":1,"userId":"123",
3251 "credentialData": [{ "credentialType": 1, "credentialId": "104",
3252 "authCode":"10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
3253 "serverPk":"","pkInfoSignature":"","pkInfo":"","peerDeviceId":"" }]})";
3254 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3255 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3256 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3257 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
3258 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
3259 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3260 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3261 }
3262
3263 /**
3264 * @tc.name: ImportCredential_003
3265 * @tc.desc: 1. set packName not null
3266 * set credentialInfo not null
3267 * 2. MOCK IpcClientProxy SendRequest return DM_OK
3268 * 3. call DeviceManagerImpl::ImportCredential with parameter
3269 * 4. check ret is DM_OK
3270 * deviceTypeId
3271 * @tc.type: FUNC
3272 * @tc.require: AR000GHSJK
3273 */
3274 HWTEST_F(DeviceManagerImplTest, ImportCredential_003, testing::ext::TestSize.Level0)
3275 {
3276 std::string packName = "com.ohos.test";
3277 std::string credentialInfo = R"({"processType":1,"authType":1,"userId":"123",
3278 "credentialData": [{ "credentialType": 1, "credentialId": "104",
3279 "authCode":"10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
3280 "serverPk":"","pkInfoSignature":"","pkInfo":"","peerDeviceId":"" }]})";
3281 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3282 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3283 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3284 .Times(1).WillOnce(testing::Return(DM_OK));
3285 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
3286 ASSERT_EQ(ret, DM_OK);
3287 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3288 }
3289
3290 /**
3291 * @tc.name: ImportCredential_004
3292 * @tc.desc: 1. set packName not null
3293 * set credentialInfo not null
3294 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3295 * 3. call DeviceManagerImpl::ImportCredential with parameter
3296 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3297 * deviceTypeId
3298 * @tc.type: FUNC
3299 * @tc.require: AR000GHSJK
3300 */
3301 HWTEST_F(DeviceManagerImplTest, ImportCredential_004, testing::ext::TestSize.Level0)
3302 {
3303 std::string packName = "com.ohos.test";
3304 std::string credentialInfo = R"({"processType":1,"authType":1,"userId":"123",
3305 "credentialData": [{ "credentialType": 1, "credentialId": "104",
3306 "authCode":"10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
3307 "serverPk":"","pkInfoSignature":"","pkInfo":"","peerDeviceId":"" }]})";
3308 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3309 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3310 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3311 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3312 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
3313 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3314 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3315 }
3316
3317 /**
3318 * @tc.name: DeleteCredential_001
3319 * @tc.desc: 1. set packName null
3320 * set deleteInfo null
3321 * 2. call DeviceManagerImpl::DeleteCredential with parameter
3322 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3323 * deviceTypeId
3324 * @tc.type: FUNC
3325 * @tc.require: AR000GHSJK
3326 */
3327 HWTEST_F(DeviceManagerImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)
3328 {
3329 std::string packName;
3330 std::string deleteInfo;
3331 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
3332 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3333 }
3334
3335 /**
3336 * @tc.name: DeleteCredential_002
3337 * @tc.desc: 1. set packName not null
3338 * set deleteInfo not null
3339 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
3340 * 3. call DeviceManagerImpl::DeleteCredential with parameter
3341 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3342 * deviceTypeId
3343 * @tc.type: FUNC
3344 * @tc.require: AR000GHSJK
3345 */
3346 HWTEST_F(DeviceManagerImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)
3347 {
3348 std::string packName = "com.ohos.test";
3349 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
3350 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3351 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3352 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3353 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
3354 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
3355 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3356 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3357 }
3358
3359 /**
3360 * @tc.name: DeleteCredential_003
3361 * @tc.desc: 1. set packName not null
3362 * set deleteInfo not null
3363 * 2. MOCK IpcClientProxy SendRequest return DM_OK
3364 * 3. call DeviceManagerImpl::DeleteCredential with parameter
3365 * 4. check ret is DM_OK
3366 * deviceTypeId
3367 * @tc.type: FUNC
3368 * @tc.require: AR000GHSJK
3369 */
3370 HWTEST_F(DeviceManagerImplTest, DeleteCredential_003, testing::ext::TestSize.Level0)
3371 {
3372 std::string packName = "com.ohos.test";
3373 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
3374 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3375 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3376 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3377 .Times(1).WillOnce(testing::Return(DM_OK));
3378 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
3379 ASSERT_EQ(ret, DM_OK);
3380 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3381 }
3382
3383 /**
3384 * @tc.name: DeleteCredential_004
3385 * @tc.desc: 1. set packName not null
3386 * set credentialInfo not null
3387 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
3388 * 3. call DeviceManagerImpl::DeleteCredential with parameter
3389 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3390 * deviceTypeId
3391 * @tc.type: FUNC
3392 * @tc.require: AR000GHSJK
3393 */
3394 HWTEST_F(DeviceManagerImplTest, DeleteCredential_004, testing::ext::TestSize.Level0)
3395 {
3396 std::string packName = "com.ohos.test";
3397 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
3398 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3399 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3400 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3401 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3402 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
3403 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3404 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3405 }
3406
3407 /**
3408 * @tc.name: RegisterCredentialCallback_001
3409 * @tc.desc: 1. set packName null
3410 * set callback null
3411 * 3. call DeviceManagerImpl::RegisterCredentialCallback with parameter
3412 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
3413 * deviceTypeId
3414 * @tc.type: FUNC
3415 * @tc.require: AR000GHSJK
3416 */
3417 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
3418 {
3419 std::string packName = "";
3420 std::shared_ptr<CredentialCallbackTest> callback = nullptr;
3421 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
3422 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3423 }
3424
3425 /**
3426 * @tc.name: RegisterCredentialCallback_002
3427 * @tc.desc: 1. set packName not null
3428 * set callback not null
3429 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
3430 * 3. check ret is DM_OK
3431 * deviceTypeId
3432 * @tc.type: FUNC
3433 * @tc.require: AR000GHSJK
3434 */
3435 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
3436 {
3437 std::string packName = "com.ohos.test";
3438 std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
3439 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3440 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3441 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3442 .Times(1).WillOnce(testing::Return(DM_OK));
3443 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
3444 ASSERT_EQ(ret, DM_OK);
3445 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3446 }
3447
3448 /**
3449 * @tc.name: RegisterCredentialCallback_003
3450 * @tc.desc: 1. set packName not null
3451 * set callback null
3452 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
3453 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3454 * deviceTypeId
3455 * @tc.type: FUNC
3456 * @tc.require: AR000GHSJK
3457 */
3458 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_003, testing::ext::TestSize.Level0)
3459 {
3460 std::string packName = "com.ohos.test";
3461 std::shared_ptr<CredentialCallbackTest> callback = nullptr;
3462 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
3463 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3464 }
3465
3466 /**
3467 * @tc.name: RegisterCredentialCallback_004
3468 * @tc.desc: 1. set packName null
3469 * set callback not null
3470 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
3471 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3472 * deviceTypeId
3473 * @tc.type: FUNC
3474 * @tc.require: AR000GHSJK
3475 */
3476 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_004, testing::ext::TestSize.Level0)
3477 {
3478 std::string packName = "";
3479 std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
3480 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
3481 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3482 }
3483
3484 /**
3485 * @tc.name: UnRegisterCredentialCallback_001
3486 * @tc.desc: 1. set packName null
3487 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
3488 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3489 * deviceTypeId
3490 * @tc.type: FUNC
3491 * @tc.require: AR000GHSJK
3492 */
3493 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
3494 {
3495 std::string packName = "";
3496 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
3497 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3498 }
3499
3500 /**
3501 * @tc.name: UnRegisterCredentialCallback_002
3502 * @tc.desc: 1. set packName not null
3503 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
3504 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3505 * deviceTypeId
3506 * @tc.type: FUNC
3507 * @tc.require: AR000GHSJK
3508 */
3509 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
3510 {
3511 std::string packName = "com.ohos.test";
3512 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3513 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3514 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3515 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
3516 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
3517 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3518 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3519 }
3520
3521 /**
3522 * @tc.name: UnRegisterCredentialCallback_003
3523 * @tc.desc: 1. set packName not null
3524 * set callback null
3525 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
3526 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
3527 * deviceTypeId
3528 * @tc.type: FUNC
3529 * @tc.require: AR000GHSJK
3530 */
3531 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_003, testing::ext::TestSize.Level0)
3532 {
3533 // 1. set packName null
3534 std::string packName = "com.ohos.test";
3535 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3536 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3537 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3538 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
3539 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
3540 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
3541 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3542 }
3543
3544 /**
3545 * @tc.name: UnRegisterCredentialCallback_004
3546 * @tc.desc: 1. set packName not null
3547 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
3548 * 3. check ret is DM_OK
3549 * deviceTypeId
3550 * @tc.type: FUNC
3551 * @tc.require: AR000GHSJK
3552 */
3553 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_004, testing::ext::TestSize.Level0)
3554 {
3555 std::string packName = "com.ohos.test";
3556 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3557 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3558 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3559 .Times(1).WillOnce(testing::Return(DM_OK));
3560 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
3561 ASSERT_EQ(ret, DM_OK);
3562 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3563 }
3564
3565 /**
3566 * @tc.name: OnDmServiceDied_001
3567 * @tc.desc: 1. mock IpcClientProxy
3568 * 2. call DeviceManagerImpl::OnDmServiceDied
3569 * 3. check ret is DM_OK
3570 * deviceTypeId
3571 * @tc.type: FUNC
3572 * @tc.require: AR000GHSJK
3573 */
3574 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_001, testing::ext::TestSize.Level0)
3575 {
3576 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3577 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3578 int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied();
3579 ASSERT_EQ(ret, DM_OK);
3580 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3581 }
3582
3583 /**
3584 * @tc.name: OnDmServiceDied_001
3585 * @tc.desc: 1. mock IpcClientProxy
3586 * 2. call DeviceManagerImpl::OnDmServiceDied
3587 * 3. check ret is DM_OK
3588 * deviceTypeId
3589 * @tc.type: FUNC
3590 * @tc.require: AR000GHSJK
3591 */
3592 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_002, testing::ext::TestSize.Level0)
3593 {
3594 // 1. mock IpcClientProxy
3595 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3596 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3597 EXPECT_CALL(*mockInstance, OnDmServiceDied()).Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
3598 // 2. call DeviceManagerImpl::OnDmServiceDied
3599 int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied();
3600 // 3. check ret is DM_OK
3601 ASSERT_EQ(ret, ERR_DM_FAILED);
3602 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3603 }
3604
3605 /**
3606 * @tc.name: NotifyEvent_001
3607 * @tc.desc: 1. mock IpcClientProxy
3608 * 2. call DeviceManagerImpl::NotifyEvent
3609 * 3. check ret is DM_OK
3610 * deviceTypeId
3611 * @tc.type: FUNC
3612 */
3613 HWTEST_F(DeviceManagerImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)
3614 {
3615 std::string packName = "com.ohos.test";
3616 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
3617 std::string event = R"({"extra": {"deviceId": "123"})";
3618 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
3619 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
3620 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
3621 .Times(1).WillOnce(testing::Return(DM_OK));
3622 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
3623 ASSERT_EQ(ret, DM_OK);
3624 DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
3625 }
3626
3627 /**
3628 * @tc.name: NotifyEvent_002
3629 * @tc.desc: 1. mock IpcClientProxy
3630 * 2. call DeviceManagerImpl::NotifyEvent
3631 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3632 * deviceTypeId
3633 * @tc.type: FUNC
3634 */
3635 HWTEST_F(DeviceManagerImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)
3636 {
3637 std::string packName = "";
3638 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
3639 std::string event = R"({"extra": {"deviceId": "123"})";
3640 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
3641 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3642 }
3643
3644 /**
3645 * @tc.name: NotifyEvent_003
3646 * @tc.desc: 1. mock IpcClientProxy
3647 * 2. call DeviceManagerImpl::NotifyEvent
3648 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3649 * deviceTypeId
3650 * @tc.type: FUNC
3651 */
3652 HWTEST_F(DeviceManagerImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)
3653 {
3654 std::string packName = "com.ohos.test";
3655 int32_t eventId = DM_NOTIFY_EVENT_START;
3656 std::string event = R"({"extra": {"deviceId": "123"})";
3657 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
3658 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3659 }
3660
3661 /**
3662 * @tc.name: NotifyEvent_004
3663 * @tc.desc: 1. mock IpcClientProxy
3664 * 2. call DeviceManagerImpl::NotifyEvent
3665 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
3666 * deviceTypeId
3667 * @tc.type: FUNC
3668 */
3669 HWTEST_F(DeviceManagerImplTest, NotifyEvent_004, testing::ext::TestSize.Level0)
3670 {
3671 std::string packName = "com.ohos.test";
3672 int32_t eventId = DM_NOTIFY_EVENT_BUTT;
3673 std::string event = R"({"extra": {"deviceId": "123"})";
3674 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
3675 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
3676 }
3677 } // namespace
3678 } // namespace DistributedHardware
3679 } // namespace OHOS