1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "UTTest_device_manager_impl.h"
17 #include "dm_device_info.h"
18
19 #include <memory>
20 #include <unistd.h>
21 #include "accesstoken_kit.h"
22 #include "device_manager_notify.h"
23 #include "dm_constants.h"
24 #include "dm_log.h"
25 #include "ipc_authenticate_device_req.h"
26 #include "ipc_get_info_by_network_req.h"
27 #include "ipc_get_info_by_network_rsp.h"
28 #include "ipc_get_local_device_info_rsp.h"
29 #include "ipc_get_trustdevice_req.h"
30 #include "ipc_get_trustdevice_rsp.h"
31 #include "ipc_req.h"
32 #include "ipc_rsp.h"
33 #include "ipc_set_useroperation_req.h"
34 #include "ipc_skeleton.h"
35 #include "ipc_publish_req.h"
36 #include "ipc_unpublish_req.h"
37 #include "ipc_unauthenticate_device_req.h"
38 #include "nativetoken_kit.h"
39 #include "securec.h"
40 #include "token_setproc.h"
41 #include "softbus_error_code.h"
42
43 namespace OHOS {
44 namespace DistributedHardware {
45 namespace {
46 /**
47 * @tc.name: RequestCredential_001
48 * @tc.desc: 1. set packName null
49 * set reqJsonStr null
50 * 2. call DeviceManagerImpl::RequestCredential with parameter
51 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
52 * deviceTypeId
53 * @tc.type: FUNC
54 * @tc.require: AR000GHSJK
55 */
56 HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
57 {
58 std::string packName;
59 std::string reqJsonStr;
60 std::string returnJsonStr;
61 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
62 returnJsonStr);
63 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
64 }
65
66 /**
67 * @tc.name: RequestCredential_002
68 * @tc.desc: 1. set packName not null
69 * set reqJsonStr not null
70 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
71 * 3. call DeviceManagerImpl::RequestCredential with parameter
72 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
73 * deviceTypeId
74 * @tc.type: FUNC
75 * @tc.require: AR000GHSJK
76 */
77 HWTEST_F(DeviceManagerImplTest, RequestCredential_002, testing::ext::TestSize.Level0)
78 {
79 std::string packName = "com.ohos.test";
80 std::string reqJsonStr = R"(
81 {
82 "version":"1.0.0.1",
83 "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
84 }
85 )";
86 std::string returnJsonStr;
87 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
88 .WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
89 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
90 returnJsonStr);
91 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
92 }
93
94 /**
95 * @tc.name: RequestCredential_003
96 * @tc.desc: 1. set packName not null
97 * set reqJsonStr not null
98 * 2. MOCK IpcClientProxy SendRequest return DM_OK
99 * 3. call DeviceManagerImpl::RequestCredential with parameter
100 * 4. check ret is DM_OK
101 * deviceTypeId
102 * @tc.type: FUNC
103 * @tc.require: AR000GHSJK
104 */
105 HWTEST_F(DeviceManagerImplTest, RequestCredential_003, testing::ext::TestSize.Level0)
106 {
107 std::string packName = "com.ohos.test";
108 std::string reqJsonStr = R"(
109 {
110 "version":"1.0.0.1",
111 "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4",
112 "CREDENTIAL_TYPE":"MINE",
113 }
114 )";
115 std::string returnJsonStr;
116 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
117 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
118 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
119 .Times(1).WillOnce(testing::Return(DM_OK));
120 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
121 returnJsonStr);
122 ASSERT_EQ(ret, DM_OK);
123 DeviceManager::GetInstance().UnInitDeviceManager(packName);
124 }
125
126 /**
127 * @tc.name: RequestCredential_004
128 * @tc.desc: 1. set packName not null
129 * set reqJsonStr not null
130 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
131 * 3. call DeviceManagerImpl::RequestCredential with parameter
132 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
133 * deviceTypeId
134 * @tc.type: FUNC
135 * @tc.require: AR000GHSJK
136 */
137 HWTEST_F(DeviceManagerImplTest, RequestCredential_004, testing::ext::TestSize.Level0)
138 {
139 std::string packName = "com.ohos.test";
140 std::string reqJsonStr = R"(
141 {
142 "version":"1.0.0.1",
143 "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
144 }
145 )";
146 std::string returnJsonStr;
147 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
148 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
149 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
150 returnJsonStr);
151 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
152 }
153
154 /**
155 * @tc.name: ImportCredential_001
156 * @tc.desc: 1. set packName null
157 * set reqJsonStr null
158 * 2. call DeviceManagerImpl::ImportCredential with parameter
159 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
160 * deviceTypeId
161 * @tc.type: FUNC
162 * @tc.require: AR000GHSJK
163 */
164 HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
165 {
166 std::string packName;
167 std::string credentialInfo;
168 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
169 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
170 }
171
172 /**
173 * @tc.name: ImportCredential_002
174 * @tc.desc: 1. set packName not null
175 * set credentialInfo not null
176 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
177 * 3. call DeviceManagerImpl::ImportCredential with parameter
178 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
179 * deviceTypeId
180 * @tc.type: FUNC
181 * @tc.require: AR000GHSJK
182 */
183 HWTEST_F(DeviceManagerImplTest, ImportCredential_002, testing::ext::TestSize.Level0)
184 {
185 std::string packName = "com.ohos.test";
186 std::string credentialInfo = R"(
187 {
188 "processType": 1,
189 "authType": 1,
190 "userId": "123",
191 "credentialData":
192 [
193 {
194 "credentialType": 1,
195 "credentialId": "104",
196 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
197 "serverPk": "",
198 "pkInfoSignature": "",
199 "pkInfo": "",
200 "peerDeviceId": ""
201 }
202 ]
203 }
204 )";
205 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
206 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
207 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
208 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
209 }
210
211 /**
212 * @tc.name: ImportCredential_003
213 * @tc.desc: 1. set packName not null
214 * set credentialInfo not null
215 * 2. MOCK IpcClientProxy SendRequest return DM_OK
216 * 3. call DeviceManagerImpl::ImportCredential with parameter
217 * 4. check ret is DM_OK
218 * deviceTypeId
219 * @tc.type: FUNC
220 * @tc.require: AR000GHSJK
221 */
222 HWTEST_F(DeviceManagerImplTest, ImportCredential_003, testing::ext::TestSize.Level0)
223 {
224 std::string packName = "com.ohos.test";
225 std::string credentialInfo = R"(
226 {
227 "processType": 1,
228 "authType": 1,
229 "userId": "123",
230 "credentialData":
231 [
232 {
233 "credentialType": 1,
234 "credentialId": "104",
235 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
236 "serverPk": "",
237 "pkInfoSignature": "",
238 "pkInfo": "",
239 "peerDeviceId": ""
240 }
241 ]
242 }
243 )";
244 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
245 .Times(1).WillOnce(testing::Return(DM_OK));
246 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
247 ASSERT_EQ(ret, DM_OK);
248 }
249
250 /**
251 * @tc.name: ImportCredential_004
252 * @tc.desc: 1. set packName not null
253 * set credentialInfo not null
254 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
255 * 3. call DeviceManagerImpl::ImportCredential with parameter
256 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
257 * deviceTypeId
258 * @tc.type: FUNC
259 * @tc.require: AR000GHSJK
260 */
261 HWTEST_F(DeviceManagerImplTest, ImportCredential_004, testing::ext::TestSize.Level0)
262 {
263 std::string packName = "com.ohos.test";
264 std::string credentialInfo = R"(
265 {
266 "processType": 1,
267 "authType": 1,
268 "userId": "123",
269 "credentialData":
270 [
271 {
272 "credentialType": 1,
273 "credentialId": "104",
274 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
275 "serverPk": "",
276 "pkInfoSignature": "",
277 "pkInfo": "",
278 "peerDeviceId": ""
279 }
280 ]
281 }
282 )";
283 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
284 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
285 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
286 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
287 }
288
289 /**
290 * @tc.name: DeleteCredential_001
291 * @tc.desc: 1. set packName null
292 * set deleteInfo null
293 * 2. call DeviceManagerImpl::DeleteCredential with parameter
294 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
295 * deviceTypeId
296 * @tc.type: FUNC
297 * @tc.require: AR000GHSJK
298 */
299 HWTEST_F(DeviceManagerImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)
300 {
301 std::string packName;
302 std::string deleteInfo;
303 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
304 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
305 }
306
307 /**
308 * @tc.name: DeleteCredential_002
309 * @tc.desc: 1. set packName not null
310 * set deleteInfo not null
311 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
312 * 3. call DeviceManagerImpl::DeleteCredential with parameter
313 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
314 * deviceTypeId
315 * @tc.type: FUNC
316 * @tc.require: AR000GHSJK
317 */
318 HWTEST_F(DeviceManagerImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)
319 {
320 std::string packName = "com.ohos.test";
321 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
322 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
323 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
324 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
325 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
326 }
327
328 /**
329 * @tc.name: DeleteCredential_003
330 * @tc.desc: 1. set packName not null
331 * set deleteInfo not null
332 * 2. MOCK IpcClientProxy SendRequest return DM_OK
333 * 3. call DeviceManagerImpl::DeleteCredential with parameter
334 * 4. check ret is DM_OK
335 * deviceTypeId
336 * @tc.type: FUNC
337 * @tc.require: AR000GHSJK
338 */
339 HWTEST_F(DeviceManagerImplTest, DeleteCredential_003, testing::ext::TestSize.Level0)
340 {
341 std::string packName = "com.ohos.test";
342 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
343 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
344 .Times(1).WillOnce(testing::Return(DM_OK));
345 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
346 ASSERT_EQ(ret, DM_OK);
347 }
348
349 /**
350 * @tc.name: DeleteCredential_004
351 * @tc.desc: 1. set packName not null
352 * set credentialInfo not null
353 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
354 * 3. call DeviceManagerImpl::DeleteCredential with parameter
355 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
356 * deviceTypeId
357 * @tc.type: FUNC
358 * @tc.require: AR000GHSJK
359 */
360 HWTEST_F(DeviceManagerImplTest, DeleteCredential_004, testing::ext::TestSize.Level0)
361 {
362 std::string packName = "com.ohos.test";
363 std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
364 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
365 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
366 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
367 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
368 }
369
370 /**
371 * @tc.name: RegisterCredentialCallback_001
372 * @tc.desc: 1. set packName null
373 * set callback null
374 * 3. call DeviceManagerImpl::RegisterCredentialCallback with parameter
375 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
376 * deviceTypeId
377 * @tc.type: FUNC
378 * @tc.require: AR000GHSJK
379 */
380 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
381 {
382 std::string packName = "";
383 std::shared_ptr<CredentialCallbackTest> callback = nullptr;
384 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
385 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
386 }
387
388 /**
389 * @tc.name: RegisterCredentialCallback_002
390 * @tc.desc: 1. set packName not null
391 * set callback not null
392 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
393 * 3. check ret is DM_OK
394 * deviceTypeId
395 * @tc.type: FUNC
396 * @tc.require: AR000GHSJK
397 */
398 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
399 {
400 std::string packName = "com.ohos.test";
401 std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
402 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
403 DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
404 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
405 .WillOnce(testing::Return(DM_OK));
406 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
407 ASSERT_EQ(ret, DM_OK);
408 DeviceManager::GetInstance().UnInitDeviceManager(packName);
409 }
410
411 /**
412 * @tc.name: RegisterCredentialCallback_003
413 * @tc.desc: 1. set packName not null
414 * set callback null
415 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
416 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
417 * deviceTypeId
418 * @tc.type: FUNC
419 * @tc.require: AR000GHSJK
420 */
421 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_003, testing::ext::TestSize.Level0)
422 {
423 std::string packName = "com.ohos.test";
424 std::shared_ptr<CredentialCallbackTest> callback = nullptr;
425 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
426 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
427 }
428
429 /**
430 * @tc.name: RegisterCredentialCallback_004
431 * @tc.desc: 1. set packName null
432 * set callback not null
433 * 2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
434 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
435 * deviceTypeId
436 * @tc.type: FUNC
437 * @tc.require: AR000GHSJK
438 */
439 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_004, testing::ext::TestSize.Level0)
440 {
441 std::string packName = "";
442 std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
443 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
444 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
445 }
446
447 /**
448 * @tc.name: UnRegisterCredentialCallback_001
449 * @tc.desc: 1. set packName null
450 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
451 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
452 * deviceTypeId
453 * @tc.type: FUNC
454 * @tc.require: AR000GHSJK
455 */
456 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
457 {
458 std::string packName = "";
459 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
460 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
461 }
462
463 /**
464 * @tc.name: UnRegisterCredentialCallback_002
465 * @tc.desc: 1. set packName not null
466 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
467 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
468 * deviceTypeId
469 * @tc.type: FUNC
470 * @tc.require: AR000GHSJK
471 */
472 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
473 {
474 std::string packName = "com.ohos.test";
475 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
476 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
477 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
478 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
479 }
480
481 /**
482 * @tc.name: UnRegisterCredentialCallback_003
483 * @tc.desc: 1. set packName not null
484 * set callback null
485 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
486 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
487 * deviceTypeId
488 * @tc.type: FUNC
489 * @tc.require: AR000GHSJK
490 */
491 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_003, testing::ext::TestSize.Level0)
492 {
493 // 1. set packName null
494 std::string packName = "com.ohos.test";
495 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
496 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
497 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
498 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
499 }
500
501 /**
502 * @tc.name: UnRegisterCredentialCallback_004
503 * @tc.desc: 1. set packName not null
504 * 2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
505 * 3. check ret is DM_OK
506 * deviceTypeId
507 * @tc.type: FUNC
508 * @tc.require: AR000GHSJK
509 */
510 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_004, testing::ext::TestSize.Level0)
511 {
512 std::string packName = "com.ohos.test";
513 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
514 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
515 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
516 .Times(1).WillOnce(testing::Return(DM_OK));
517 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
518 ASSERT_EQ(ret, DM_OK);
519 DeviceManager::GetInstance().UnInitDeviceManager(packName);
520 }
521
522 /**
523 * @tc.name: OnDmServiceDied_001
524 * @tc.desc: 1. mock IpcClientProxy
525 * 2. call DeviceManagerImpl::OnDmServiceDied
526 * 3. check ret is DM_OK
527 * deviceTypeId
528 * @tc.type: FUNC
529 * @tc.require: AR000GHSJK
530 */
531 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_001, testing::ext::TestSize.Level0)
532 {
533 int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied();
534 ASSERT_EQ(ret, DM_OK);
535 }
536
537 /**
538 * @tc.name: OnDmServiceDied_001
539 * @tc.desc: 1. mock IpcClientProxy
540 * 2. call DeviceManagerImpl::OnDmServiceDied
541 * 3. check ret is DM_OK
542 * deviceTypeId
543 * @tc.type: FUNC
544 * @tc.require: AR000GHSJK
545 */
546 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_002, testing::ext::TestSize.Level0)
547 {
548 // 1. mock IpcClientProxy
549 EXPECT_CALL(*ipcClientProxyMock_, OnDmServiceDied()).Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
550 // 2. call DeviceManagerImpl::OnDmServiceDied
551 int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied();
552 // 3. check ret is DM_OK
553 ASSERT_EQ(ret, ERR_DM_FAILED);
554 }
555
556 /**
557 * @tc.name: NotifyEvent_001
558 * @tc.desc: 1. mock IpcClientProxy
559 * 2. call DeviceManagerImpl::NotifyEvent
560 * 3. check ret is DM_OK
561 * deviceTypeId
562 * @tc.type: FUNC
563 */
564 HWTEST_F(DeviceManagerImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)
565 {
566 std::string packName = "com.ohos.test";
567 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
568 std::string event = R"({"extra": {"deviceId": "123"})";
569 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
570 .Times(1).WillOnce(testing::Return(DM_OK));
571 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
572 ASSERT_EQ(ret, DM_OK);
573 }
574
575 /**
576 * @tc.name: NotifyEvent_002
577 * @tc.desc: 1. mock IpcClientProxy
578 * 2. call DeviceManagerImpl::NotifyEvent
579 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
580 * deviceTypeId
581 * @tc.type: FUNC
582 */
583 HWTEST_F(DeviceManagerImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)
584 {
585 std::string packName = "";
586 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
587 std::string event = R"({"extra": {"deviceId": "123"})";
588 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
589 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
590 }
591
592 /**
593 * @tc.name: NotifyEvent_003
594 * @tc.desc: 1. mock IpcClientProxy
595 * 2. call DeviceManagerImpl::NotifyEvent
596 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
597 * deviceTypeId
598 * @tc.type: FUNC
599 */
600 HWTEST_F(DeviceManagerImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)
601 {
602 std::string packName = "com.ohos.test";
603 int32_t eventId = DM_NOTIFY_EVENT_START;
604 std::string event = R"({"extra": {"deviceId": "123"})";
605 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
606 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
607 }
608
609 /**
610 * @tc.name: NotifyEvent_004
611 * @tc.desc: 1. mock IpcClientProxy
612 * 2. call DeviceManagerImpl::NotifyEvent
613 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
614 * deviceTypeId
615 * @tc.type: FUNC
616 */
617 HWTEST_F(DeviceManagerImplTest, NotifyEvent_004, testing::ext::TestSize.Level0)
618 {
619 std::string packName = "com.ohos.test";
620 int32_t eventId = DM_NOTIFY_EVENT_BUTT;
621 std::string event = R"({"extra": {"deviceId": "123"})";
622 int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
623 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
624 }
625
626 /**
627 * @tc.name: CheckAPIAccessPermission_001
628 * @tc.desc: 1. InitDeviceManager
629 * 2. call DeviceManagerImpl::CheckAPIAccessPermission
630 * 3. check ret is DM_OK
631 * 4. UnInitDeviceManager
632 * deviceTypeId
633 * @tc.type: FUNC
634 */
635 HWTEST_F(DeviceManagerImplTest, CheckAPIAccessPermission_001, testing::ext::TestSize.Level0)
636 {
637 std::string packName = "com.ohos.test";
638 std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
639 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
640 DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
641 int32_t ret = DeviceManager::GetInstance().CheckAPIAccessPermission();
642 ASSERT_EQ(ret, DM_OK);
643 DeviceManager::GetInstance().UnInitDeviceManager(packName);
644 }
645
646 /**
647 * @tc.name: RegisterDevStatusCallback_001
648 * @tc.desc: 1. InitDeviceManager
649 * 2. call DeviceManagerImpl::RegisterDevStatusCallback
650 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
651 * deviceTypeId
652 * @tc.type: FUNC
653 */
654 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_001, testing::ext::TestSize.Level0)
655 {
656 std::string pkgName;
657 std::string extra;
658 std::shared_ptr<DeviceStatusCallback> callback = nullptr;
659 int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(pkgName, extra, callback);
660 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
661 }
662
663 /**
664 * @tc.name: RegisterDevStatusCallback_002
665 * @tc.desc: 1. InitDeviceManager
666 * 2. call DeviceManagerImpl::RegisterDevStatusCallback
667 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
668 * deviceTypeId
669 * @tc.type: FUNC
670 */
671 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_002, testing::ext::TestSize.Level0)
672 {
673 std::string packName = "com.ohos.test";
674 std::string extra;
675 std::shared_ptr<DeviceStatusCallback> callback = nullptr;
676 int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(packName, extra, callback);
677 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
678 }
679
680 /**
681 * @tc.name: RegisterDevStatusCallback_003
682 * @tc.desc: 1. InitDeviceManager
683 * 2. call DeviceManagerImpl::RegisterDevStatusCallback
684 * 3. check ret is DM_OK
685 * deviceTypeId
686 * @tc.type: FUNC
687 */
688 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_003, testing::ext::TestSize.Level0)
689 {
690 std::string packName = "com.ohos.test";
691 std::string extra;
692 std::shared_ptr<DeviceStatusCallback> callback = std::make_shared<DeviceStatusCallbackTest>();
693 int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(packName, extra, callback);
694 ASSERT_EQ(ret, DM_OK);
695 }
696
697 /**
698 * @tc.name: UnRegisterDevStatusCallback_001
699 * @tc.desc: 1. InitDeviceManager
700 * 2. call DeviceManagerImpl::UnRegisterDevStatusCallback
701 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
702 * deviceTypeId
703 * @tc.type: FUNC
704 */
705 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_001, testing::ext::TestSize.Level0)
706 {
707 std::string packName;
708 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStatusCallback(packName);
709 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
710 }
711
712 /**
713 * @tc.name: UnRegisterDevStatusCallback_002
714 * @tc.desc: 1. InitDeviceManager
715 * 2. call DeviceManagerImpl::UnRegisterDevStatusCallback
716 * 3. check ret is DM_OK
717 * deviceTypeId
718 * @tc.type: FUNC
719 */
720 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_002, testing::ext::TestSize.Level0)
721 {
722 std::string packName = "com.ohos.test";
723 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStatusCallback(packName);
724 ASSERT_EQ(ret, DM_OK);
725 }
726
727 /**
728 * @tc.name: StartDeviceDiscovery_104
729 * @tc.desc: 1. set packName null
730 * set subscribeId 0
731 * set filterOptions null
732 * set callback not null
733 * 2. InitDeviceManager return DM_OK
734 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
735 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
736 * deviceTypeId
737 * @tc.type: FUNC
738 * @tc.require: AR000GHSJK
739 */
740 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_104, testing::ext::TestSize.Level0)
741 {
742 std::string packName;
743 uint16_t subscribeId = 0;
744 std::string filterOptions;
745 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
746 DmDeviceBasicInfo deviceBasicInfo;
747 callback->OnDeviceFound(subscribeId, deviceBasicInfo);
748 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
749 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
750 ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
751 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
752 DeviceManager::GetInstance().UnInitDeviceManager(packName);
753 }
754
755 /**
756 * @tc.name: StartDeviceDiscovery_105
757 * @tc.desc: 1. set packName not null
758 * set subscribeId 0
759 * set filterOptions null
760 * set callback not null
761 * 2. InitDeviceManager return DM_OK
762 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
763 * 4. check ret is ERR_DM_INPUT_PARA_INVALID
764 * deviceTypeId
765 * @tc.type: FUNC
766 * @tc.require: AR000GHSJK
767 */
768 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_105, testing::ext::TestSize.Level0)
769 {
770 std::string packName = "com.ohos.test";
771 uint16_t subscribeId = 0;
772 std::string filterOptions;
773 std::shared_ptr<DiscoveryCallback> callback = nullptr;
774 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
775 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
776 }
777
778 /**
779 * @tc.name: StartDeviceDiscovery_106
780 * @tc.desc: 1. set packName not null
781 * set subscribeId 0
782 * set filterOptions not null
783 * set callback not null
784 * 2. InitDeviceManager return DM_OK
785 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
786 * 4. check ret is DM_OK
787 * deviceTypeId
788 * @tc.type: FUNC
789 * @tc.require: AR000GHSJK
790 */
791 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_106, testing::ext::TestSize.Level0)
792 {
793 std::string packName = "com.ohos.test";
794 uint16_t subscribeId = -1;
795 std::string filterOptions = "filterOptions";
796 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
797 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
798 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
799 ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
800 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
801 DeviceManager::GetInstance().UnInitDeviceManager(packName);
802 }
803
804 /**
805 * @tc.name: RequestCredential_101
806 * @tc.desc: 1. set packName not null
807 * set reqJsonStr not null
808 * 2. MOCK IpcClientProxy SendRequest return DM_OK
809 * 3. call DeviceManagerImpl::RequestCredential with parameter
810 * 4. check ret is DM_OK
811 * deviceTypeId
812 * @tc.type: FUNC
813 * @tc.require: AR000GHSJK
814 */
815 HWTEST_F(DeviceManagerImplTest, RequestCredential_101, testing::ext::TestSize.Level0)
816 {
817 std::string packName = "com.ohos.test";
818 std::string returnJsonStr;
819 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
820 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
821 int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, returnJsonStr);
822 DeviceManager::GetInstance().UnInitDeviceManager(packName);
823 ASSERT_EQ(ret, DM_OK);
824 }
825
826 /**
827 * @tc.name: CheckCredential_101
828 * @tc.desc: 1. set packName not null
829 * set credentialInfo not null
830 * 2. MOCK IpcClientProxy SendRequest return DM_OK
831 * 3. call DeviceManagerImpl::ImportCredential with parameter
832 * 4. check ret is DM_OK
833 * deviceTypeId
834 * @tc.type: FUNC
835 * @tc.require: AR000GHSJK
836 */
837 HWTEST_F(DeviceManagerImplTest, CheckCredential_101, testing::ext::TestSize.Level0)
838 {
839 std::string packName = "com.ohos.test";
840 std::string credentialInfo = "{\n}";
841 std::string returnJsonStr;
842 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
843 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
844 int32_t ret = DeviceManager::GetInstance().CheckCredential(packName, credentialInfo, returnJsonStr);
845 DeviceManager::GetInstance().UnInitDeviceManager(packName);
846 ASSERT_EQ(ret, DM_OK);
847 }
848
849 /**
850 * @tc.name: ImportCredential_101
851 * @tc.desc: 1. set packName not null
852 * set credentialInfo not null
853 * 2. MOCK IpcClientProxy SendRequest return DM_OK
854 * 3. call DeviceManagerImpl::ImportCredential with parameter
855 * 4. check ret is DM_OK
856 * deviceTypeId
857 * @tc.type: FUNC
858 * @tc.require: AR000GHSJK
859 */
860 HWTEST_F(DeviceManagerImplTest, ImportCredential_101, testing::ext::TestSize.Level0)
861 {
862 std::string packName = "com.ohos.test";
863 std::string credentialInfo = R"(
864 {
865 "processType": 1,
866 "authType": 1,
867 "userId": "123",
868 "credentialData":
869 [
870 {
871 "credentialType": 1,
872 "credentialId": "104",
873 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
874 "serverPk": "",
875 "pkInfoSignature": "",
876 "pkInfo": "",
877 "peerDeviceId": ""
878 }
879 ]
880 }
881 )";
882 std::string returnJsonStr;
883 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
884 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
885 int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo, returnJsonStr);
886 DeviceManager::GetInstance().UnInitDeviceManager(packName);
887 ASSERT_EQ(ret, DM_OK);
888 }
889
890 /**
891 * @tc.name: DeleteCredential_101
892 * @tc.desc: 1. set packName not null
893 * set deleteInfo not null
894 * 2. MOCK IpcClientProxy SendRequest return DM_OK
895 * 3. call DeviceManagerImpl::DeleteCredential with parameter
896 * 4. check ret is DM_OK
897 * deviceTypeId
898 * @tc.type: FUNC
899 * @tc.require: AR000GHSJK
900 */
901 HWTEST_F(DeviceManagerImplTest, DeleteCredential_101, testing::ext::TestSize.Level0)
902 {
903 std::string packName = "com.ohos.test";
904 std::string credentialInfo = R"({"isDeleteAll":true})";
905 std::string returnJsonStr;
906 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
907 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
908 int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, credentialInfo, returnJsonStr);
909 DeviceManager::GetInstance().UnInitDeviceManager(packName);
910 ASSERT_EQ(ret, DM_OK);
911 }
912 HWTEST_F(DeviceManagerImplTest, VerifyAuthentication001, testing::ext::TestSize.Level0)
913 {
914 std::string pkgName;
915 std::string authPara;
916 std::shared_ptr<VerifyAuthCallback> callback = nullptr;
917 int32_t ret = DeviceManager::GetInstance().VerifyAuthentication(pkgName, authPara, callback);
918 ASSERT_EQ(ret, DM_OK);
919 }
920
921 HWTEST_F(DeviceManagerImplTest, GetFaParam001, testing::ext::TestSize.Level0)
922 {
923 std::string pkgName;
924 DmAuthParam dmFaParam;
925 int32_t ret = DeviceManager::GetInstance().GetFaParam(pkgName, dmFaParam);
926 ASSERT_EQ(ret, DM_OK);
927 }
928
929 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback001, testing::ext::TestSize.Level0)
930 {
931 std::string pkgName;
932 std::string extra;
933 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra);
934 ASSERT_EQ(ret, DM_OK);
935 }
936
937 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback001, testing::ext::TestSize.Level0)
938 {
939 std::string pkgName;
940 std::string extra;
941 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(pkgName, extra);
942 ASSERT_EQ(ret, DM_OK);
943 }
944
945 HWTEST_F(DeviceManagerImplTest, RequestCredential001, testing::ext::TestSize.Level0)
946 {
947 std::string pkgName;
948 std::string reqJsonStr;
949 std::string returnJsonStr;
950 int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, reqJsonStr, returnJsonStr);
951 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
952 }
953
954 HWTEST_F(DeviceManagerImplTest, RequestCredential002, testing::ext::TestSize.Level0)
955 {
956 std::string pkgName = "pkgName";
957 std::string reqJsonStr;
958 std::string returnJsonStr;
959 int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, reqJsonStr, returnJsonStr);
960 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
961 }
962
963 HWTEST_F(DeviceManagerImplTest, RequestCredential003, testing::ext::TestSize.Level0)
964 {
965 std::string pkgName = "pkgName";
966 std::string reqJsonStr = "reqJsonStr";
967 std::string returnJsonStr;
968 int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, reqJsonStr, returnJsonStr);
969 EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
970 }
971
972 HWTEST_F(DeviceManagerImplTest, ImportCredential001, testing::ext::TestSize.Level0)
973 {
974 std::string pkgName;
975 std::string credentialInfo;
976 int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, credentialInfo);
977 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
978 }
979
980 HWTEST_F(DeviceManagerImplTest, ImportCredential002, testing::ext::TestSize.Level0)
981 {
982 std::string pkgName = "pkgName";
983 std::string credentialInfo;
984 int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, credentialInfo);
985 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
986 }
987
988 HWTEST_F(DeviceManagerImplTest, ImportCredential003, testing::ext::TestSize.Level0)
989 {
990 std::string pkgName = "pkgName";
991 std::string credentialInfo = "credentialInfo";
992 int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, credentialInfo);
993 EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
994 }
995
996 HWTEST_F(DeviceManagerImplTest, DeleteCredential001, testing::ext::TestSize.Level0)
997 {
998 std::string pkgName;
999 std::string deleteInfo;
1000 int32_t ret = DeviceManager::GetInstance().DeleteCredential(pkgName, deleteInfo);
1001 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1002 }
1003
1004 HWTEST_F(DeviceManagerImplTest, DeleteCredential002, testing::ext::TestSize.Level0)
1005 {
1006 std::string pkgName = "pkgName";
1007 std::string deleteInfo;
1008 int32_t ret = DeviceManager::GetInstance().DeleteCredential(pkgName, deleteInfo);
1009 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1010 }
1011
1012 HWTEST_F(DeviceManagerImplTest, DeleteCredential003, testing::ext::TestSize.Level0)
1013 {
1014 std::string pkgName = "pkgName";
1015 std::string deleteInfo = "deleteInfo";
1016 int32_t ret = DeviceManager::GetInstance().DeleteCredential(pkgName, deleteInfo);
1017 EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1018 }
1019
1020 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback001, testing::ext::TestSize.Level0)
1021 {
1022 std::string pkgName;
1023 std::shared_ptr<CredentialCallback> callback = nullptr;
1024 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(pkgName, callback);
1025 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1026 }
1027
1028 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback002, testing::ext::TestSize.Level0)
1029 {
1030 std::string pkgName = "pkgName";
1031 std::shared_ptr<CredentialCallback> callback = nullptr;
1032 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(pkgName, callback);
1033 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1034 }
1035
1036 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback001, testing::ext::TestSize.Level0)
1037 {
1038 std::string pkgName;
1039 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(pkgName);
1040 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1041 }
1042
1043 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback002, testing::ext::TestSize.Level0)
1044 {
1045 DeviceManagerImpl::GetInstance().ipcClientProxy_->ipcClientManager_ = nullptr;
1046 std::string pkgName = "pkgName";
1047 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(pkgName);
1048 EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1049 DeviceManagerImpl::GetInstance().ipcClientProxy_->ipcClientManager_ = std::make_shared<IpcClientManager>();
1050 }
1051
SetSetDnPolicyPermission()1052 void SetSetDnPolicyPermission()
1053 {
1054 const int32_t permsNum = 1;
1055 const int32_t indexZero = 0;
1056 uint64_t tokenId;
1057 const char *perms[permsNum];
1058 perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
1059 NativeTokenInfoParams infoInstance = {
1060 .dcapsNum = 0,
1061 .permsNum = permsNum,
1062 .aclsNum = 0,
1063 .dcaps = NULL,
1064 .perms = perms,
1065 .acls = NULL,
1066 .processName = "collaboration_service",
1067 .aplStr = "system_core",
1068 };
1069 tokenId = GetAccessTokenId(&infoInstance);
1070 SetSelfTokenID(tokenId);
1071 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
1072 }
1073
1074 HWTEST_F(DeviceManagerImplTest, SetDnPolicy001, testing::ext::TestSize.Level0)
1075 {
1076 SetSetDnPolicyPermission();
1077 std::string packName = "com.ohos.test";
1078 std::map<std::string, std::string> policy;
1079 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
1080 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
1081 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1082 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1083 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1084 bool bRet = false;
1085 if (ret == DM_OK || ret == ERR_DM_UNSUPPORTED_METHOD) {
1086 bRet = true;
1087 }
1088 ASSERT_EQ(bRet, true);
1089 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1090 }
1091
1092 HWTEST_F(DeviceManagerImplTest, SetDnPolicy002, testing::ext::TestSize.Level0)
1093 {
1094 SetSetDnPolicyPermission();
1095 std::string packName = "com.ohos.test";
1096 std::map<std::string, std::string> policy;
1097 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
1098 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1099 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1100 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1101 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1102 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1103 }
1104
1105 HWTEST_F(DeviceManagerImplTest, SetDnPolicy003, testing::ext::TestSize.Level0)
1106 {
1107 SetSetDnPolicyPermission();
1108 std::string packName = "com.ohos.test";
1109 std::map<std::string, std::string> policy;
1110 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1111 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1112 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1113 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1114 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1115 }
1116
1117 HWTEST_F(DeviceManagerImplTest, SetDnPolicy004, testing::ext::TestSize.Level0)
1118 {
1119 SetSetDnPolicyPermission();
1120 std::string packName;
1121 std::map<std::string, std::string> policy;
1122 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1123 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1124 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1125 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1126 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1127 }
1128
1129 HWTEST_F(DeviceManagerImplTest, SetDnPolicy005, testing::ext::TestSize.Level0)
1130 {
1131 SetSetDnPolicyPermission();
1132 std::string packName;
1133 std::map<std::string, std::string> policy;
1134 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
1135 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
1136 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1137 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1138 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1139 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1140 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1141 }
1142
1143 HWTEST_F(DeviceManagerImplTest, SetDnPolicy006, testing::ext::TestSize.Level0)
1144 {
1145 SetSetDnPolicyPermission();
1146 std::string packName = "com.ohos.test";
1147 std::map<std::string, std::string> policy;
1148 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
1149 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
1150 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1151 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1152 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1153 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1154 }
1155
1156 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_301, testing::ext::TestSize.Level0)
1157 {
1158 std::string packName;
1159 uint64_t tokenId = 123;
1160 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1161 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1162 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(tokenId, packName);
1163 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1164 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1165 }
1166
1167 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_302, testing::ext::TestSize.Level0)
1168 {
1169 std::string packName = "com.ohos.test";
1170 uint64_t tokenId = 123;
1171 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1172 DeviceManagerImpl::GetInstance().InitDeviceManager(packName, callback);
1173 DeviceManagerImpl::GetInstance().StopDeviceDiscovery(tokenId, packName);
1174 int32_t ret = DeviceManagerImpl::GetInstance().StopDeviceDiscovery(tokenId, packName);
1175 ASSERT_NE(ret, DM_OK);
1176 DeviceManagerImpl::GetInstance().UnInitDeviceManager(packName);
1177 }
1178
1179 HWTEST_F(DeviceManagerImplTest, RegisterUiStateCallback_301, testing::ext::TestSize.Level0)
1180 {
1181 std::string packName;
1182 int32_t ret = DeviceManagerImpl::GetInstance().RegisterUiStateCallback(packName);
1183 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1184 }
1185
1186 HWTEST_F(DeviceManagerImplTest, UnRegisterUiStateCallback_301, testing::ext::TestSize.Level0)
1187 {
1188 std::string packName;
1189 DeviceManager::GetInstance().CheckNewAPIAccessPermission();
1190 int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterUiStateCallback(packName);
1191 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1192 }
1193
1194 HWTEST_F(DeviceManagerImplTest, StopAdvertising_301, testing::ext::TestSize.Level0)
1195 {
1196 std::string packName;
1197 std::map<std::string, std::string> advertiseParam;
1198 int32_t ret = DeviceManager::GetInstance().StopAdvertising(packName, advertiseParam);
1199 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1200 }
1201
1202 HWTEST_F(DeviceManagerImplTest, CheckAccessToTarget_301, testing::ext::TestSize.Level0)
1203 {
1204 uint64_t tokenId = 123;
1205 std::string targetId;
1206 int32_t ret = DeviceManager::GetInstance().CheckAccessToTarget(tokenId, targetId);
1207 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
1208 }
1209
1210 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_301, testing::ext::TestSize.Level0)
1211 {
1212 std::string pkgName;
1213 std::shared_ptr<DevTrustChangeCallback> callback = nullptr;
1214 int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback);
1215 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1216 }
1217
1218 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_302, testing::ext::TestSize.Level0)
1219 {
1220 std::string pkgName = "com.ohos.test";
1221 std::shared_ptr<DevTrustChangeCallback> callback = nullptr;
1222 int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback);
1223 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1224 }
1225
1226 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_303, testing::ext::TestSize.Level0)
1227 {
1228 std::string pkgName = "com.ohos.test";
1229 std::shared_ptr<DevTrustChangeCallback> callback = std::make_shared<DevTrustChangeCallbackTest>();
1230 int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback);
1231 ASSERT_EQ(ret, DM_OK);
1232 }
1233
1234 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_304, testing::ext::TestSize.Level0)
1235 {
1236 std::string pkgName;
1237 std::shared_ptr<DevTrustChangeCallback> callback = std::make_shared<DevTrustChangeCallbackTest>();
1238 int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback);
1239 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1240 }
1241
1242 HWTEST_F(DeviceManagerImplTest, GetErrCode_301, testing::ext::TestSize.Level0)
1243 {
1244 int32_t errCode = ERR_DM_TIME_OUT;
1245 int32_t ret = DeviceManager::GetInstance().GetErrCode(errCode);
1246 ASSERT_EQ(ret, 96929745);
1247 }
1248
1249 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_001, testing::ext::TestSize.Level0)
1250 {
1251 std::string packName = "";
1252 std::shared_ptr<DeviceScreenStatusCallbackTest> callback = std::make_shared<DeviceScreenStatusCallbackTest>();
1253 int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1254 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1255 }
1256
1257 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_002, testing::ext::TestSize.Level0)
1258 {
1259 std::string packName = "com.ohos.screenStatustest01";
1260 std::shared_ptr<DeviceScreenStatusCallbackTest> callback = nullptr;
1261 int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1262 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1263 }
1264
1265 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_003, testing::ext::TestSize.Level0)
1266 {
1267 std::string packName = "com.ohos.screenStatustest02";
1268 std::shared_ptr<DeviceScreenStatusCallbackTest> callback = std::make_shared<DeviceScreenStatusCallbackTest>();
1269 int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1270 ASSERT_EQ(ret, DM_OK);
1271 }
1272
1273 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_001, testing::ext::TestSize.Level0)
1274 {
1275 std::string packName = "com.ohos.screenStatustest03";
1276 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceScreenStatusCallback(packName);
1277 ASSERT_EQ(ret, DM_OK);
1278 }
1279
1280 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_002, testing::ext::TestSize.Level0)
1281 {
1282 std::string packName = "";
1283 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceScreenStatusCallback(packName);
1284 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1285 }
1286
1287 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_001, testing::ext::TestSize.Level0)
1288 {
1289 std::string packName = "com.ohos.screenStatustest04";
1290 std::string networkId = "networkIdTest";
1291 int32_t screenStatus = -1;
1292 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1293 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1294 int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
1295 ASSERT_NE(ret, ERR_DM_TIME_OUT);
1296 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1297 }
1298
1299 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_002, testing::ext::TestSize.Level0)
1300 {
1301 std::string packName = "com.ohos.screenStatustest05";
1302 std::string networkId = "";
1303 int32_t screenStatus = -1;
1304 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1305 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1306 int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
1307 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1308 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1309 }
1310
1311 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_003, testing::ext::TestSize.Level0)
1312 {
1313 std::string packName = "";
1314 std::string networkId = "networkIdTest";
1315 int32_t screenStatus = -1;
1316 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1317 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1318 int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
1319 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1320 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1321 }
1322
1323 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_001, testing::ext::TestSize.Level0)
1324 {
1325 std::string packName = "";
1326 std::shared_ptr<CandidateRestrictStatusCallbackTest> callback =
1327 std::make_shared<CandidateRestrictStatusCallbackTest>();
1328 int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1329 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1330 }
1331
1332 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_002, testing::ext::TestSize.Level0)
1333 {
1334 std::string packName = "com.ohos.candidateRestrict01";
1335 std::shared_ptr<CandidateRestrictStatusCallbackTest> callback = nullptr;
1336 int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1337 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1338 }
1339
1340 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_003, testing::ext::TestSize.Level0)
1341 {
1342 std::string packName = "com.ohos.scandidateRestrict02";
1343 std::shared_ptr<CandidateRestrictStatusCallbackTest> callback =
1344 std::make_shared<CandidateRestrictStatusCallbackTest>();
1345 int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1346 ASSERT_EQ(ret, DM_OK);
1347 }
1348
1349 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_001, testing::ext::TestSize.Level0)
1350 {
1351 std::string packName = "com.ohos.candidateRestrict03";
1352 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialAuthStatusCallback(packName);
1353 ASSERT_EQ(ret, DM_OK);
1354 }
1355
1356 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_002, testing::ext::TestSize.Level0)
1357 {
1358 std::string packName = "";
1359 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialAuthStatusCallback(packName);
1360 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1361 }
1362
1363 HWTEST_F(DeviceManagerImplTest, RegisterAuthenticationType_001, testing::ext::TestSize.Level0)
1364 {
1365 std::string packName = "";
1366 std::map<std::string, std::string> authParam;
1367 int32_t ret = DeviceManager::GetInstance().RegisterAuthenticationType(packName, authParam);
1368 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1369 }
1370
1371 HWTEST_F(DeviceManagerImplTest, RegisterAuthenticationType_002, testing::ext::TestSize.Level0)
1372 {
1373 std::string packName = "com.ohos.RegisterAuthenticationType";
1374 std::map<std::string, std::string> authParam;
1375 int32_t ret = DeviceManager::GetInstance().RegisterAuthenticationType(packName, authParam);
1376 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1377 }
1378
1379 HWTEST_F(DeviceManagerImplTest, RegisterAuthenticationType_003, testing::ext::TestSize.Level0)
1380 {
1381 std::string packName = "";
1382 std::map<std::string, std::string> authParam;
1383 authParam[DM_AUTHENTICATION_TYPE] = "0";
1384 int32_t ret = DeviceManager::GetInstance().RegisterAuthenticationType(packName, authParam);
1385 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1386 }
1387
1388 HWTEST_F(DeviceManagerImplTest, RegisterAuthenticationType_004, testing::ext::TestSize.Level0)
1389 {
1390 std::string packName = "com.ohos.RegisterAuthenticationType";
1391 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1392 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1393 std::map<std::string, std::string> authParam;
1394 authParam[DM_AUTHENTICATION_TYPE] = "0";
1395 int32_t ret = DeviceManager::GetInstance().RegisterAuthenticationType(packName, authParam);
1396 ASSERT_EQ(ret, DM_OK);
1397 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1398 }
1399
1400 HWTEST_F(DeviceManagerImplTest, UnRegisterPinHolderCallback_001, testing::ext::TestSize.Level0)
1401 {
1402 std::string packName = "com.ohos.UnRegisterPinHolderCallback";
1403 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1404 DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1405 int32_t ret = DeviceManager::GetInstance().UnRegisterPinHolderCallback(packName);
1406 ASSERT_EQ(ret, DM_OK);
1407 DeviceManager::GetInstance().UnInitDeviceManager(packName);
1408 }
1409
1410 HWTEST_F(DeviceManagerImplTest, ImportAuthCode_301, testing::ext::TestSize.Level0)
1411 {
1412 std::string pkgName = "com.ohos.test";
1413 std::string authCode;
1414 authCode.append(1025, 'a');
1415 int32_t ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1416 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1417 }
1418
1419 HWTEST_F(DeviceManagerImplTest, ImportAuthCode_302, testing::ext::TestSize.Level0)
1420 {
1421 std::string pkgName = "com.ohos.ImportAuthCode";
1422 std::string authCode = "950800";
1423 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1424 .Times(1)
1425 .WillOnce(testing::Return(DM_OK));
1426 int32_t ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1427 ASSERT_EQ(ret, DM_OK);
1428 }
1429
1430 HWTEST_F(DeviceManagerImplTest, ExportAuthCode_301, testing::ext::TestSize.Level0)
1431 {
1432 std::string authCode;
1433 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_))
1434 .Times(1)
1435 .WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1436 int32_t ret = DeviceManager::GetInstance().ExportAuthCode(authCode);
1437 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1438 }
1439 } // namespace
1440 } // namespace DistributedHardware
1441 } // namespace OHOS
1442