1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "UTTest_device_manager_impl.h"
17 #include "dm_device_info.h"
18 
19 #include <unistd.h>
20 #include "accesstoken_kit.h"
21 #include "device_manager_notify.h"
22 #include "dm_constants.h"
23 #include "dm_log.h"
24 #include "ipc_authenticate_device_req.h"
25 #include "ipc_get_info_by_network_req.h"
26 #include "ipc_get_info_by_network_rsp.h"
27 #include "ipc_get_local_device_info_rsp.h"
28 #include "ipc_get_trustdevice_req.h"
29 #include "ipc_get_trustdevice_rsp.h"
30 #include "ipc_req.h"
31 #include "ipc_rsp.h"
32 #include "ipc_set_useroperation_req.h"
33 #include "ipc_skeleton.h"
34 #include "ipc_start_discovery_req.h"
35 #include "ipc_stop_discovery_req.h"
36 #include "ipc_publish_req.h"
37 #include "ipc_unpublish_req.h"
38 #include "ipc_unauthenticate_device_req.h"
39 #include "nativetoken_kit.h"
40 #include "securec.h"
41 #include "token_setproc.h"
42 
43 namespace OHOS {
44 namespace DistributedHardware {
45 namespace {
46 /**
47  * @tc.name: StopDeviceDiscovery_001
48  * @tc.desc: 1. set packName null
49  *              set subscribeId is 0
50  *           2. call DeviceManagerImpl::StopDeviceDiscovery 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, StopDeviceDiscovery_001, testing::ext::TestSize.Level0)
57 {
58     // 1. set packName null
59     std::string packName = "";
60     // set subscribeInfo is 0
61     uint16_t subscribeId = 0;
62     // 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
63     int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
64     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
65     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
66 }
67 
68 /**
69  * @tc.name: StopDeviceDiscovery_002
70  * @tc.desc: 1. set packName not null
71  *                     set subscribeId is 0
72  *                  2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
73  *                  2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
74  *                  3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
75  * deviceTypeId
76  * @tc.type: FUNC
77  * @tc.require: AR000GHSJK
78  */
79 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0)
80 {
81     // 1. set packName not null
82     std::string packName = "com.ohos.test";
83     // set subscribeInfo is 0
84     uint16_t subscribeId = 0;
85     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
86     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
87     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
88     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
89     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
90                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
91     // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
92     int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
93     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
94     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
95     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
96 }
97 
98 /**
99  * @tc.name: StopDeviceDiscovery_003
100  * @tc.desc: 1. set packName not null
101  *              set subscribeId is 0
102  *           2. MOCK IpcClientProxy SendRequest return DM_OK
103  *           3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
104  *           4. check ret is DM_OK
105  * deviceTypeId
106  * @tc.type: FUNC
107  * @tc.require: AR000GHSJK
108  */
109 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_003, testing::ext::TestSize.Level0)
110 {
111     // 1. set packName not null
112     std::string packName = "com.ohos.test";
113     // set subscribeInfo is 0
114     uint16_t subscribeId = 0;
115     // 2. MOCK IpcClientProxy SendRequest return DM_OK
116     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
117     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
118     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
119     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
120                 .Times(1).WillOnce(testing::Return(DM_OK));
121     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
122     // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
123     int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
124     // 4. check ret is DM_OK
125     ASSERT_EQ(ret, DM_OK);
126     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
127 }
128 
129 /**
130  * @tc.name: StopDeviceDiscovery_004
131  * @tc.desc: 1. set packName not null
132  *              set subscribeId is 0
133  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
134  *           3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
135  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
136  * deviceTypeId
137  * @tc.type: FUNC
138  * @tc.require: AR000GHSJK
139  */
140 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_004, testing::ext::TestSize.Level0)
141 {
142     // 1. set packName not null
143     std::string packName = "com.ohos.test";
144     // set subscribeInfo is 0
145     uint16_t subscribeId = 0;
146     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
147     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
148     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
149     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
150     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
151                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
152     // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
153     int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
154     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
155     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
156     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
157 }
158 
159 /**
160  * @tc.name: StopDeviceDiscovery_005
161  * @tc.desc: 1. set packName not null
162  *              set subscribeId is 0
163  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
164  *           3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
165  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
166  * deviceTypeId
167  * @tc.type: FUNC
168  * @tc.require: AR000GHSJK
169  */
170 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_005, testing::ext::TestSize.Level0)
171 {
172     // 1. set packName not null
173     std::string packName = "com.ohos.test";
174     // set subscribeInfo is 0
175     uint16_t subscribeId = 0;
176     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
177     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
178     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
179     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
180     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
181                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
182     // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
183     int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
184     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
185     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
186     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
187 }
188 
189 /**
190  * @tc.name: PublishDeviceDiscovery_001
191  * @tc.desc: 1. set packName null
192  *              set subscribeInfo null
193  *              set callback null
194  *           2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
195  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
196  * deviceTypeId
197  * @tc.type: FUNC
198  * @tc.require: I5N1K3
199  */
200 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
201 {
202     // 1. set packName null
203     std::string packName = "";
204     // set publishInfo null
205     DmPublishInfo publishInfo;
206     // set callback null
207     std::shared_ptr<PublishCallback> callback = nullptr;
208     // 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
209     int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
210     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
211     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
212 }
213 
214 /**
215  * @tc.name: PublishDeviceDiscovery_002
216  * @tc.desc: 1. set packName null
217  *              set subscribeInfo null
218  *              set callback null
219  *           2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
220  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
221  * deviceTypeId
222  * @tc.type: FUNC
223  * @tc.require: I5N1K3
224  */
225 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
226 {
227     // 1. set packName null
228     std::string packName = "com.ohos.helloworld";
229     // set publishInfo null
230     DmPublishInfo publishInfo;
231     // set callback null
232     std::shared_ptr<PublishCallback> callback = nullptr;
233     // 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
234     int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
235     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
236     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
237 }
238 
239 /**
240  * @tc.name: PublishDeviceDiscovery_003
241  * @tc.desc: 1. set packName null
242  *              set publishInfo null
243  *              set callback null
244  *           2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
245  *           3. check ret is DEVICEMANAGER_INVALID_VALUE
246  * deviceTypeId
247  * @tc.type: FUNC
248  * @tc.require: I5N1K3
249  */
250 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
251 {
252     // 1. set packName not null
253     std::string packName = "com.ohos.test";
254     // set publishInfo is 0
255     DmPublishInfo publishInfo;
256     std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
257     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
258     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
259     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
260     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
261     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
262                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
263     // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
264     int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
265     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
266     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
267     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
268 }
269 
270 /**
271  * @tc.name: PublishDeviceDiscovery_004
272  * @tc.desc: 1. set packName not null
273  *              set publishInfo null
274  *              set callback not null
275  *           2. MOCK IpcClientProxy SendRequest return DM_OK
276  *           3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
277  *           4. check ret is DM_OK
278  * deviceTypeId
279  * @tc.type: FUNC
280  * @tc.require: I5N1K3
281  */
282 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_004, testing::ext::TestSize.Level0)
283 {
284     // 1. set packName not null
285     std::string packName = "com.ohos.helloworld";
286     // set publishInfo null
287     DmPublishInfo publishInfo;
288     // set callback not null
289     std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
290     // 2. MOCK IpcClientProxy SendRequest return DM_OK
291     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
292     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
293     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
294     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
295                 .Times(1).WillOnce(testing::Return(DM_OK));
296     // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
297     int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
298     // 4. check ret is DM_OK
299     ASSERT_EQ(ret, DM_OK);
300     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
301 }
302 
303 /**
304  * @tc.name:PublishDeviceDiscovery_005
305  * @tc.desc: 1. set packName not null
306  *              set subscribeInfo null
307  *              set callback not null
308  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
309  *           3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
310  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
311  * deviceTypeId
312  * @tc.type: FUNC
313  * @tc.require: I5N1K3
314  */
315 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_005, testing::ext::TestSize.Level0)
316 {
317     // 1. set packName not null
318     std::string packName = "com.ohos.helloworld";
319     // set publishInfo null
320     DmPublishInfo publishInfo;
321     // set callback not null
322     std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
323     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
324     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
325     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
326     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
327     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
328                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
329     // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
330     int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
331     // 4. check ret is DEVICEMANAGER_IPC_FAILED
332     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
333     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
334 }
335 
336 /**
337  * @tc.name: UnPublishDeviceDiscovery_001
338  * @tc.desc: 1. set packName null
339  *              set publishId is 0
340  *           2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
341  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
342  * deviceTypeId
343  * @tc.type: FUNC
344  * @tc.require: I5N1K3
345  */
346 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
347 {
348     // 1. set packName null
349     std::string packName = "";
350     // set publishId is 0
351     int32_t publishId = 0;
352     // 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
353     int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
354     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
355     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
356 }
357 
358 /**
359  * @tc.name: UnPublishDeviceDiscovery_002
360  * @tc.desc: 1. set packName not null
361  *              set publishId is 0
362  *           2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
363  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
364  * deviceTypeId
365  * @tc.type: FUNC
366  * @tc.require: I5N1K3
367  */
368 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
369 {
370     // 1. set packName not null
371     std::string packName = "com.ohos.test";
372     // set subscribeInfo is 0
373     int32_t publishId = 0;
374     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
375     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
376     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
377     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
378     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
379                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
380     // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
381     int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
382     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
383     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
384     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
385 }
386 
387 /**
388  * @tc.name: UnPublishDeviceDiscovery_003
389  * @tc.desc: 1. set packName not null
390  *              set publishId is 0
391  *           2. MOCK IpcClientProxy SendRequest return DM_OK
392  *           3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
393  *           4. check ret is DM_OK
394  * deviceTypeId
395  * @tc.type: FUNC
396  * @tc.require: I5N1K3
397  */
398 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
399 {
400     // 1. set packName not null
401     std::string packName = "com.ohos.test";
402     // set subscribeInfo is 0
403     int32_t publishId = 0;
404     // 2. MOCK IpcClientProxy SendRequest return DM_OK
405     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
406     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
407     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
408     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
409                 .Times(1).WillOnce(testing::Return(DM_OK));
410     // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
411     int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
412     // 4. check ret is DM_OK
413     ASSERT_EQ(ret, DM_OK);
414     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
415 }
416 
417 /**
418  * @tc.name: UnPublishDeviceDiscovery_004
419  * @tc.desc: 1. set packName not null
420  *              set publishId is 0
421  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
422  *           3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
423  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
424  * deviceTypeId
425  * @tc.type: FUNC
426  * @tc.require: I5N1K3
427  */
428 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_004, testing::ext::TestSize.Level0)
429 {
430     // 1. set packName not null
431     std::string packName = "com.ohos.test";
432     // set publishId is 0
433     int32_t publishId = 0;
434     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
435     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
436     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
437     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
438     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
439                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
440     // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
441     int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
442     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
443     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
444     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
445 }
446 
447 /**
448  * @tc.name: UnPublishDeviceDiscovery_005
449  * @tc.desc: 1. set packName not null
450  *              set publishId is 0
451  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
452  *           3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
453  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
454  * deviceTypeId
455  * @tc.type: FUNC
456  * @tc.require: I5N1K3
457  */
458 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_005, testing::ext::TestSize.Level0)
459 {
460     // 1. set packName not null
461     std::string packName = "com.ohos.test";
462     // set publishId is 0
463     int32_t publishId = 0;
464     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
465     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
466     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
467     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
468     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
469                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
470     // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
471     int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
472     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
473     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
474     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
475 }
476 
477 /**
478  * @tc.name: AuthenticateDevice_001
479  * @tc.desc: 1. set packName = null
480  *              set dmDeviceInfo = null
481  *              set dmAppImageInfo = null
482  *              set extra = null
483  *              set callback = nullptr
484  *           2. call DeviceManagerImpl::AuthenticateDevice with parameter
485  *           3. check ret is DEVICEMANAGER_INVALID_VALUE
486  * deviceTypeId
487  * @tc.type: FUNC
488  * @tc.require: AR000GHSJK
489  */
490 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
491 {
492     // 1. set packName = null
493     std::string packName = "";
494     int32_t authType = 1;
495     // set dmDeviceInfo = null
496     DmDeviceInfo dmDeviceInfo;
497     // set extra = null
498     std::string extra = "";
499     // set callback = nullptr
500     std::shared_ptr<AuthenticateCallback> callback = nullptr;
501     // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
502     int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
503     // 3. check ret is DEVICEMANAGER_INVALID_VALUE
504     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
505 }
506 
507 /**
508  * @tc.name: AuthenticateDevice_002
509  * @tc.desc: 1. set packName not null
510  *              set dmDeviceInfo null
511  *              set dmAppImageInfo null
512  *              set extra null
513  *              set callback null
514  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
515  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
516  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
517  * deviceTypeId
518  * @tc.type: FUNC
519  * @tc.require: AR000GHSJK
520  */
521 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
522 {
523     // 1. set packName not null
524     std::string packName = "com.ohos.helloworld";
525     int32_t authType = 1;
526     // set dmDeviceInfo null
527     DmDeviceInfo dmDeviceInfo;
528     // set extra null
529     std::string extra = "";
530     // set callback null
531     std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>();
532     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
533     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
534     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
535     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
536     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
537                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
538     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
539     int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
540     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
541     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
542     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
543 }
544 
545 /**
546  * @tc.name: AuthenticateDevice_003
547  * @tc.desc: 1. set packName not null
548  *              set dmDeviceInfo null
549  *              set dmAppImageInfo null
550  *              set extra null
551  *              set callback null
552  *           2. MOCK IpcClientProxy SendRequest return DM_OK
553  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
554  *           4. check ret is DM_OK
555  * deviceTypeId
556  * @tc.type: FUNC
557  * @tc.require: AR000GHSJK
558  */
559 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
560 {
561     // 1. set packName not null
562     std::string packName = "com.ohos.helloworld";
563     // set dmDeviceInfo null
564     int32_t authType = 1;
565     // set dmAppImageInfo null
566     DmDeviceInfo dmDeviceInfo;
567     // set extra null
568     std::string extra = "";
569     // set callback null
570     std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>();
571     // 2. MOCK IpcClientProxy SendRequest return DM_OK
572     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
573     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
574     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
575     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
576                 .Times(1).WillOnce(testing::Return(DM_OK));
577     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
578     int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
579     // 4. check ret is DM_OK
580     ASSERT_EQ(ret, DM_OK);
581     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
582 }
583 
584 /**
585  * @tc.name: AuthenticateDevice_004
586  * @tc.desc: 1. set packName not null
587  *              set dmDeviceInfo null
588  *              set dmAppImageInfo null
589  *              set extra null
590  *              set callback null
591  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
592  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
593  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
594  * deviceTypeId
595  * @tc.type: FUNC
596  * @tc.require: AR000GHSJK
597  */
598 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_004, testing::ext::TestSize.Level0)
599 {
600     // 1. set packName not null
601     std::string packName = "com.ohos.helloworld";
602     // set dmDeviceInfo null
603     int32_t authType = 1;
604     // set dmAppImageInfo null
605     DmDeviceInfo dmDeviceInfo;
606     // set extra null
607     std::string extra = "";
608     // set callback null
609     std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>();
610     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
611     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
612     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
613     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
614     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
615                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
616     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
617     int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
618     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
619     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
620     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
621 }
622 
623 /**
624  * @tc.name: AuthenticateDevice_005
625  * @tc.desc: 1. set packName not null
626  *              set dmDeviceInfo null
627  *              set dmAppImageInfo null
628  *              set extra null
629  *              set callback null
630  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
631  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
632  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
633  * deviceTypeId
634  * @tc.type: FUNC
635  * @tc.require: AR000GHSJK
636  */
637 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_005, testing::ext::TestSize.Level0)
638 {
639     // 1. set packName not null
640     std::string packName = "com.ohos.helloworld";
641     // set dmDeviceInfo null
642     int32_t authType = 1;
643     // set dmAppImageInfo null
644     DmDeviceInfo dmDeviceInfo;
645     // set extra null
646     std::string extra = "";
647     // set callback null
648     std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>();
649     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
650     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
651     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
652     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
653     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
654                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
655     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
656     int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
657     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
658     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
659     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
660 }
661 
662 /**
663  * @tc.name: UnAuthenticateDevice_001
664  * @tc.desc: 1. set packName = null
665  *              set dmDeviceInfo = null
666  *              set dmAppImageInfo = null
667  *              set extra = null
668  *              set callback = nullptr
669  *           2. call DeviceManagerImpl::AuthenticateDevice with parameter
670  *           3. check ret is DEVICEMANAGER_INVALID_VALUE
671  * deviceTypeId
672  * @tc.type: FUNC
673  * @tc.require: AR000GHSJK
674  */
675 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
676 {
677     // 1. set packName = null
678     std::string packName = "";
679     DmDeviceInfo deviceInfo;
680     // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
681     int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
682     // 3. check ret is DEVICEMANAGER_INVALID_VALUE
683     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
684 }
685 
686 /**
687  * @tc.name: UnAuthenticateDevice_002
688  * @tc.desc: 1. set packName not null
689  *              set dmDeviceInfo null
690  *              set dmAppImageInfo null
691  *              set extra null
692  *              set callback null
693  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
694  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
695  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
696  * deviceTypeId
697  * @tc.type: FUNC
698  * @tc.require: AR000GHSJK
699  */
700 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
701 {
702     // 1. set packName = null
703     std::string packName = "com.ohos.helloworld";
704     DmDeviceInfo deviceInfo;
705     deviceInfo.deviceId[0] = '\0';
706     // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
707     int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
708     // 3. check ret is DEVICEMANAGER_INVALID_VALUE
709     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
710 }
711 
712 /**
713  * @tc.name: UnAuthenticateDevice_003
714  * @tc.desc: 1. set packName not null
715  *              set dmDeviceInfo null
716  *              set dmAppImageInfo null
717  *              set extra null
718  *              set callback null
719  *           2. MOCK IpcClientProxy SendRequest return DM_OK
720  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
721  *           4. check ret is DM_OK
722  * deviceTypeId
723  * @tc.type: FUNC
724  * @tc.require: AR000GHSJK
725  */
726 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
727 {
728     // 1. set packName not null
729     std::string packName = "com.ohos.helloworld";
730     DmDeviceInfo deviceInfo;
731     deviceInfo.networkId[0] = '1';
732     deviceInfo.networkId[1] = '2';
733     deviceInfo.networkId[2] = '\0';
734     // set callback null
735     std::shared_ptr<AuthenticateCallback> callback = nullptr;
736     // 2. MOCK IpcClientProxy SendRequest return DM_OK
737     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
738     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
739     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
740     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
741                 .Times(1).WillOnce(testing::Return(DM_OK));
742     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
743     int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
744     // 4. check ret is DM_OK
745     ASSERT_EQ(ret, DM_OK);
746     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
747 }
748 
749 /**
750  * @tc.name: UnAuthenticateDevice_004
751  * @tc.desc: 1. set packName not null
752  *              set dmDeviceInfo null
753  *              set dmAppImageInfo null
754  *              set extra null
755  *              set callback null
756  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
757  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
758  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
759  * deviceTypeId
760  * @tc.type: FUNC
761  * @tc.require: AR000GHSJK
762  */
763 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0)
764 {
765     // 1. set packName not null
766     std::string packName = "com.ohos.helloworld";
767     // set dmDeviceInfo null
768     DmDeviceInfo deviceInfo;
769     deviceInfo.networkId[0] = '1';
770     deviceInfo.networkId[1] = '2';
771     deviceInfo.networkId[2] = '\0';
772     std::shared_ptr<AuthenticateCallback> callback = nullptr;
773     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
774     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
775     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
776     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
777     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
778                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
779     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
780     int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
781     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
782     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
783     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
784 }
785 
786 /**
787  * @tc.name: UnAuthenticateDevice_005
788  * @tc.desc: 1. set packName not null
789  *              set dmDeviceInfo null
790  *              set dmAppImageInfo null
791  *              set extra null
792  *              set callback null
793  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
794  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
795  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
796  * deviceTypeId
797  * @tc.type: FUNC
798  * @tc.require: AR000GHSJK
799  */
800 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_005, testing::ext::TestSize.Level0)
801 {
802     // 1. set packName not null
803     std::string packName = "com.ohos.helloworld";
804     // set dmDeviceInfo null
805     DmDeviceInfo deviceInfo;
806     deviceInfo.networkId[0] = '1';
807     deviceInfo.networkId[1] = '2';
808     deviceInfo.networkId[2] = '\0';
809     std::shared_ptr<AuthenticateCallback> callback = nullptr;
810     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
811     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
812     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
813     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
814     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
815                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
816     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
817     int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
818     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
819     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
820     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
821 }
822 
823 /**
824  * @tc.name: SetUserOperation_001
825  * @tc.desc: 1. set packName null
826  *              set action null
827  *           2. call DeviceManagerImpl::SetUserOperation with parameter
828  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
829  * deviceTypeId
830  * @tc.type: FUNC
831  * @tc.require: AR000GHSJK
832  */
833 HWTEST_F(DeviceManagerImplTest, SetUserOperation_001, testing::ext::TestSize.Level0)
834 {
835     // 1. set packName null
836     std::string packName = "";
837     // set authParam null
838     int32_t action = 0;
839     const std::string param = "extra";
840     // 2. call DeviceManagerImpl::SetUserOperation with parameter
841     int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
842     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
843     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
844 }
845 
846 /**
847  * @tc.name: SetUserOperation_002
848  * @tc.desc: 1. set packName not null
849  *              set action null
850  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
851  *           3. call DeviceManagerImpl::SetUserOperation with parameter
852  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
853  * deviceTypeId
854  * @tc.type: FUNC
855  * @tc.require: AR000GHSJK
856  */
857 HWTEST_F(DeviceManagerImplTest, SetUserOperation_002, testing::ext::TestSize.Level0)
858 {
859     // 1. set packName null
860     std::string packName = "com.ohos.test";
861     // set authParam null
862     int32_t action = 0;
863     const std::string param = "extra";
864     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
865     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
866     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
867     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
868     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
869                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
870     // 3. call DeviceManagerImpl::SetUserOperation with parameter
871     int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
872     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
873     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
874     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
875 }
876 
877 /**
878  * @tc.name: SetUserOperation_003
879  * @tc.desc: 1. set packName not null
880  *              set action null
881  *           2. MOCK IpcClientProxy SendRequest return DM_OK
882  *           3. call DeviceManagerImpl::SetUserOperation with parameter
883  *           4. check ret is DM_OK
884  * deviceTypeId
885  * @tc.type: FUNC
886  * @tc.require: AR000GHSJK
887  */
888 HWTEST_F(DeviceManagerImplTest, SetUserOperation_003, testing::ext::TestSize.Level0)
889 {
890     // 1. set packName not null
891     std::string packName = "com.ohos.test";
892     // set authParam null
893     int32_t action = 0;
894     const std::string param = "extra";
895     // 2. MOCK IpcClientProxy SendRequest return DM_OK
896     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
897     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
898     // 3. call DeviceManagerImpl::SetUserOperation with parameter
899     ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
900     // 4. check ret is DM_OK
901     ASSERT_EQ(ret, DM_OK);
902     DeviceManager::GetInstance().UnInitDeviceManager(packName);
903 }
904 
905 /**
906  * @tc.name: SetUserOperation_004
907  * @tc.desc: 1. set packName not null
908  *              set action null
909  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
910  *           3. call DeviceManagerImpl::SetUserOperation with parameter
911  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
912  * deviceTypeId
913  * @tc.type: FUNC
914  * @tc.require: AR000GHSJK
915  */
916 HWTEST_F(DeviceManagerImplTest, SetUserOperation_004, testing::ext::TestSize.Level0)
917 {
918     // 1. set packName null
919     std::string packName = "com.ohos.test";
920     // set authParam null
921     int32_t action = 0;
922     const std::string param = "extra";
923     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
924     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
925     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
926     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
927     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
928                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
929     // 3. call DeviceManagerImpl::SetUserOperation with parameter
930     int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
931     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
932     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
933     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
934 }
935 
936 /**
937  * @tc.name: SetUserOperation_005
938  * @tc.desc: 1. set packName not null
939  *               set action null
940  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
941  *           3. call DeviceManagerImpl::SetUserOperation with parameter
942  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
943  * deviceTypeId
944  * @tc.type: FUNC
945  * @tc.require: AR000GHSJK
946  */
947 HWTEST_F(DeviceManagerImplTest, SetUserOperation_005, testing::ext::TestSize.Level0)
948 {
949     // 1. set packName null
950     std::string packName = "com.ohos.test";
951     // set authParam null
952     int32_t action = 0;
953     const std::string param = "extra";
954     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
955     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
956     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
957     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
958     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
959                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
960     // 3. call DeviceManagerImpl::SetUserOperation with parameter
961     int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
962     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
963     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
964     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
965 }
966 
967 /**
968  * @tc.name: GetUdidByNetworkId_001
969  * @tc.desc: 1. set packName null
970  *              set action null
971  *           2. call DeviceManagerImpl::SetUserOperation with parameter
972  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
973  * deviceTypeId
974  * @tc.type: FUNC
975  * @tc.require: AR000GHSJK
976  */
977 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0)
978 {
979     // 1. set packName null
980     std::string packName = "";
981     // set authParam null
982     std::string netWorkId = "111";
983     std::string udid = "222";
984     // 2. call DeviceManagerImpl::SetUserOperation with parameter
985     int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
986     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
987     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
988 }
989 
990 /**
991  * @tc.name: GetUdidByNetworkId_002
992  * @tc.desc: 1. set packName not null
993  *              set action null
994  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
995  *           3. call DeviceManagerImpl::SetUserOperation with parameter
996  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
997  * deviceTypeId
998  * @tc.type: FUNC
999  * @tc.require: AR000GHSJK
1000  */
1001 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0)
1002 {
1003     // 1. set packName null
1004     std::string packName = "com.ohos.test";
1005     // set authParam null
1006     std::string netWorkId = "111";
1007     std::string udid = "222";
1008     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1009     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1010     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1011     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1012     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1013                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1014     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1015     int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
1016     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1017     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1018     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1019 }
1020 
1021 /**
1022  * @tc.name: GetUdidByNetworkId_003
1023  * @tc.desc: 1. set packName not null
1024  *              set action null
1025  *           2. MOCK IpcClientProxy SendRequest return DM_OK
1026  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1027  *           4. check ret is DM_OK
1028  * deviceTypeId
1029  * @tc.type: FUNC
1030  * @tc.require: AR000GHSJK
1031  */
1032 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0)
1033 {
1034     // 1. set packName not null
1035     std::string packName = "com.ohos.test";
1036     // set authParam null
1037     std::string netWorkId = "111";
1038     std::string udid = "222";
1039     // 2. MOCK IpcClientProxy SendRequest return DM_OK
1040     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1041     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1042     // 3. call DeviceManagerImpl::GetUdidByNetworkId with parameter
1043     ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
1044     // 4. check ret is DM_OK
1045     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1046     // DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1047     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1048 }
1049 
1050 /**
1051  * @tc.name: GetUdidByNetworkId_004
1052  * @tc.desc: 1. set packName not null
1053  *              set action null
1054  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1055  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1056  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1057  * deviceTypeId
1058  * @tc.type: FUNC
1059  * @tc.require: AR000GHSJK
1060  */
1061 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_004, testing::ext::TestSize.Level0)
1062 {
1063     // 1. set packName null
1064     std::string packName = "com.ohos.test";
1065     // set authParam null
1066     std::string netWorkId = "111";
1067     std::string udid = "222";
1068     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1069     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1070     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1071     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1072     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1073                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1074     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1075     int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
1076     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1077     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1078     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1079 }
1080 
1081 /**
1082  * @tc.name: GetUdidByNetworkId_005
1083  * @tc.desc: 1. set packName not null
1084  *                     set action null
1085  *                  2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1086  *                  3. call DeviceManagerImpl::SetUserOperation with parameter
1087  *                  4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1088  * deviceTypeId
1089  * @tc.type: FUNC
1090  * @tc.require: AR000GHSJK
1091  */
1092 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_005, testing::ext::TestSize.Level0)
1093 {
1094     // 1. set packName null
1095     std::string packName = "com.ohos.test";
1096     // set authParam null
1097     std::string netWorkId = "111";
1098     std::string udid = "222";
1099     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1100     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1101     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1102     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1103     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1104                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
1105     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1106     int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
1107     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1108     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1109     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1110 }
1111 
1112 /**
1113  * @tc.name: GetUuidByNetworkId_001
1114  * @tc.desc: 1. set packName null
1115  *              set action null
1116  *           2. call DeviceManagerImpl::SetUserOperation with parameter
1117  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1118  * deviceTypeId
1119  * @tc.type: FUNC
1120  * @tc.require: AR000GHSJK
1121  */
1122 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)
1123 {
1124     // 1. set packName null
1125     std::string packName = "";
1126     // set authParam null
1127     std::string netWorkId = "111";
1128     std::string uuid = "222";
1129     // 2. call DeviceManagerImpl::SetUserOperation with parameter
1130     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1131     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1132     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1133 }
1134 
1135 /**
1136  * @tc.name: GetUuidByNetworkId_002
1137  * @tc.desc: 1. set packName not null
1138  *              set action null
1139  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1140  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1141  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1142  * deviceTypeId
1143  * @tc.type: FUNC
1144  * @tc.require: AR000GHSJK
1145  */
1146 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0)
1147 {
1148     // 1. set packName null
1149     std::string packName = "com.ohos.test";
1150     // set authParam null
1151     std::string netWorkId = "111";
1152     std::string uuid = "222";
1153     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1154     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1155     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1156     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1157     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1158                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1159     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1160     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1161     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1162     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1163     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1164 }
1165 
1166 /**
1167  * @tc.name: GetUuidByNetworkId_003
1168  * @tc.desc: 1. set packName not null
1169  *              set action null
1170  *           2. MOCK IpcClientProxy SendRequest return DM_OK
1171  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1172  *           4. check ret is DM_OK
1173  * deviceTypeId
1174  * @tc.type: FUNC
1175  * @tc.require: AR000GHSJK
1176  */
1177 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0)
1178 {
1179     // 1. set packName not null
1180     std::string packName = "com.ohos.test";
1181     // set authParam null
1182     std::string netWorkId = "111";
1183     std::string uuid = "222";
1184     // 2. MOCK IpcClientProxy SendRequest return DM_OK
1185     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1186     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1187     // 3. call DeviceManagerImpl::GetUuidByNetworkId with parameter
1188     ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1189     // 4. check ret is DM_OK
1190     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1191     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1192 }
1193 
1194 /**
1195  * @tc.name: GetUuidByNetworkId_004
1196  * @tc.desc: 1. set packName not null
1197  *              set action null
1198  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1199  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1200  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1201  * deviceTypeId
1202  * @tc.type: FUNC
1203  * @tc.require: AR000GHSJK
1204  */
1205 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_004, testing::ext::TestSize.Level0)
1206 {
1207     // 1. set packName null
1208     std::string packName = "com.ohos.test";
1209     // set authParam null
1210     std::string netWorkId = "111";
1211     std::string uuid = "222";
1212     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1213     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1214     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1215     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1216     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1217                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1218     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1219     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1220     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1221     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1222     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1223 }
1224 
1225 /**
1226  * @tc.name: GetUuidByNetworkId_005
1227  * @tc.desc: 1. set packName not null
1228  *                     set action null
1229  *                  2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1230  *                  3. call DeviceManagerImpl::SetUserOperation with parameter
1231  *                  4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1232  * deviceTypeId
1233  * @tc.type: FUNC
1234  * @tc.require: AR000GHSJK
1235  */
1236 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_005, testing::ext::TestSize.Level0)
1237 {
1238     // 1. set packName null
1239     std::string packName = "com.ohos.test";
1240     // set authParam null
1241     std::string netWorkId = "111";
1242     std::string uuid = "222";
1243     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1244     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1245     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1246     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1247     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1248                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
1249     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1250     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1251     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1252     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1253     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1254 }
1255 
1256 /**
1257  * @tc.name: RegisterDeviceManagerFaCallback_001
1258  * @tc.desc: 1. set packName not null
1259  *              set action null
1260  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1261  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1262  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
1263  * deviceTypeId
1264  * @tc.type: FUNC
1265  * @tc.require: AR000GHSJK
1266  */
1267 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)
1268 {
1269     // 1. set packName null
1270     std::string packName = "";
1271     // set callback null
1272     std::shared_ptr<DeviceManagerUiCallback> callback = nullptr;
1273     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1274     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1275     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1276     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1277 }
1278 
1279 /**
1280  * @tc.name: RegisterDeviceManagerFaCallback_002
1281  * @tc.desc: 1. set packName not null
1282  *              set callback not null
1283  *           2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1284  *           3. check ret is DM_OK
1285  * deviceTypeId
1286  * @tc.type: FUNC
1287  * @tc.require: AR000GHSJK
1288  */
1289 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)
1290 {
1291     // 1. set packName null
1292     std::string packName = "com.ohos.test";
1293     // set callback null
1294     std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
1295     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1296     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1297     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1298     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1299     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1300                 .Times(1).WillOnce(testing::Return(DM_OK));
1301     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1302     // 3. check ret is DM_OK
1303     ASSERT_EQ(ret, DM_OK);
1304     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1305 }
1306 
1307 /**
1308  * @tc.name: RegisterDeviceManagerFaCallback_003
1309  * @tc.desc: 1. set packName not null
1310  *              set callback not null
1311  *           2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1312  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1313  * deviceTypeId
1314  * @tc.type: FUNC
1315  * @tc.require: AR000GHSJK
1316  */
1317 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)
1318 {
1319     // 1. set packName null
1320     std::string packName = "com.ohos.test";
1321     // set callback null
1322     std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr;
1323     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1324     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1325     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1326     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1327 }
1328 
1329 /**
1330  * @tc.name: RegisterDeviceManagerFaCallback_004
1331  * @tc.desc: 1. set packName not null
1332  *              set callback not null
1333  *           2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1334  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1335  * deviceTypeId
1336  * @tc.type: FUNC
1337  * @tc.require: AR000GHSJK
1338  */
1339 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)
1340 {
1341     // 1. set packName null
1342     std::string packName = "";
1343     // set callback null
1344     std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
1345     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1346     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1347     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1348     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1349 }
1350 
1351 /**
1352  * @tc.name: RegisterDeviceManagerFaCallback_005
1353  * @tc.desc: 1. set packName not null
1354  *              set callback not null
1355  *           2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1356  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1357  * deviceTypeId
1358  * @tc.type: FUNC
1359  * @tc.require: AR000GHSJK
1360  */
1361 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)
1362 {
1363     // 1. set packName null
1364     std::string packName ("");
1365     // set callback null
1366     std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr;
1367     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1368     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1369     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1370     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1371 }
1372 
1373 /**
1374  * @tc.name: UnRegisterDeviceManagerFaCallback_001
1375  * @tc.desc: 1. set packName null
1376  *           2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter
1377  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1378  * deviceTypeId
1379  * @tc.type: FUNC
1380  * @tc.require: AR000GHSJK
1381  */
1382 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)
1383 {
1384     // 1. set packName null
1385     std::string packName = "";
1386     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1387     int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName);
1388     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1389     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1390 }
1391 
1392 /**
1393  * @tc.name: UnRegisterDeviceManagerFaCallback_002
1394  * @tc.desc: 1. set packName not null
1395  *           2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter
1396  *           3. check ret is DM_OK
1397  * deviceTypeId
1398  * @tc.type: FUNC
1399  * @tc.require: AR000GHSJK
1400  */
1401 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)
1402 {
1403     // 1. set packName null
1404     std::string packName = "com.ohos.test";
1405     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1406     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1407     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1408     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1409     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1410                 .Times(1).WillOnce(testing::Return(DM_OK));
1411     int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName);
1412     // 3. check ret is DM_OK
1413     ASSERT_EQ(ret, DM_OK);
1414     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1415 }
1416 
1417 /**
1418  * @tc.name: UnRegisterDeviceManagerFaCallback_003
1419  * @tc.desc: 1. set packName not null
1420  *              set callback not null
1421  *           2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
1422  *           3. check ret is DM_OK
1423  *           4. set checkMap null
1424  *           5. Get checkMap from DeviceManagerNotify
1425  *           6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1426  *           7. Get checkMap from pkgName
1427  *           8. check checkMap null
1428  * deviceTypeId
1429  * @tc.type: FUNC
1430  * @tc.require: AR000GHSJK
1431  */
1432 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)
1433 {
1434     // 1. set pkgName not null
1435     std::string pkgName = "com.ohos.test";
1436     // set callback not null
1437     std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
1438     // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
1439     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1440     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1441     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1442     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1443                 .Times(1).WillOnce(testing::Return(DM_OK));
1444     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
1445     // 3. check ret is DM_OK
1446     ASSERT_EQ(ret, DM_OK);
1447     // 4. set checkMap null
1448     std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
1449     // 5. Get checkMap from DeviceManagerNotify
1450     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1451     // 5. check checkMap not null
1452     ASSERT_NE(checkMap, nullptr);
1453     // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1454     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1455                 .Times(1).WillOnce(testing::Return(DM_OK));
1456     DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(pkgName);
1457     // 7. Get checkMap from pkgName
1458     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1459     // 8 check checkMap null
1460     ASSERT_EQ(checkMap, nullptr);
1461     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1462 }
1463 
1464 /**
1465  * @tc.name: UnRegisterDeviceManagerFaCallback_004
1466  * @tc.desc: 1. set packName not null
1467  *              set callback not null
1468  *           2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
1469  *           3. check ret is DM_OK
1470  *           4. set checkMap null
1471  *           5. Get checkMap from DeviceManagerNotify
1472  *           6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1473  *           7. Get checkMap from pkgName
1474  *           8. check checkMap null
1475  * deviceTypeId
1476  * @tc.type: FUNC
1477  * @tc.require: AR000GHSJK
1478  */
1479 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)
1480 {
1481     // 1. set pkgName not null
1482     std::string pkgName = "com.ohos.test";
1483     // set callback not null
1484     std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
1485     // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
1486     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1487     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1488     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1489     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1490                 .Times(1).WillOnce(testing::Return(DM_OK));
1491     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
1492     // 3. check ret is DM_OK
1493     ASSERT_EQ(ret, DM_OK);
1494     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1495     // 4. set checkMap null
1496     std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
1497     // 5. Get checkMap from DeviceManagerNotify
1498     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1499     // 5. check checkMap not null
1500     ASSERT_NE(checkMap, nullptr);
1501     // 6. set unRegisterPkgNamr different from pkgName
1502     std::string unRegisterPkgName = "com.ohos.test1";
1503     // 7. call DeviceManager UnRegisterDeviceManagerFaCallback with unRegisterPkgName
1504     DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName);
1505     // 7. Get checkMap from pkgName
1506     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1507     // 8 check checkMap not null
1508     ASSERT_NE(checkMap, nullptr);
1509 }
1510 
1511 /**
1512  * @tc.name: UnRegisterDeviceManagerFaCallback_005
1513  * @tc.desc: 1. set packName not null
1514  *           2. Set checkMap null
1515  *           3. Get checkMap from DeviceManagerNotify
1516  *           4. check checkMap not null
1517  *           5. Set unRegisterPkgName is different from register pkgName
1518  *           6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1519  *           7. Get checkMap from DeviceManagerNotify
1520  *           8. check checkMap not null
1521  * deviceTypeId
1522  * @tc.type: FUNC
1523  * @tc.require: AR000GHSJK
1524  */
1525 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)
1526 {
1527     // 1. set pkgName not null
1528     std::string pkgName = "com.ohos.test";
1529     // 2. Set checkMap null
1530     std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
1531     // 3. Get checkMap from DeviceManagerNotify
1532     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1533     // 4. check checkMap not null
1534     ASSERT_NE(checkMap, nullptr);
1535     // 5. Set unRegisterPkgName is different from register pkgName
1536     std::string unRegisterPkgName = "com.ohos.test1";
1537     // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1538     DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName);
1539     // 7. Get checkMap from DeviceManagerNotify
1540     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1541     // 8. check checkMap not null
1542     ASSERT_NE(checkMap, nullptr);
1543 }
1544 } // namespace
1545 } // namespace DistributedHardware
1546 } // namespace OHOS