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