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  */
HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_005, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_005, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_005, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)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 = "{\"status\":1}";
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  */
HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)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 = "{\"status\":1}";
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  */
HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_004, testing::ext::TestSize.Level0)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 = "{\"status\":1}";
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  */
HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_005, testing::ext::TestSize.Level0)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 = "{\"status\":1}";
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  */
HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_005, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, SetUserOperation_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, SetUserOperation_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, SetUserOperation_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, SetUserOperation_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, SetUserOperation_005, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0)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<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1041     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1042     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1043     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1044                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1045     // 3. call DeviceManagerImpl::GetUdidByNetworkId with parameter
1046     int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
1047     // 4. check ret is DM_OK
1048     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1049     // DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
1050     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1051 }
1052 
1053 /**
1054  * @tc.name: GetUdidByNetworkId_004
1055  * @tc.desc: 1. set packName not null
1056  *              set action null
1057  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1058  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1059  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1060  * deviceTypeId
1061  * @tc.type: FUNC
1062  * @tc.require: AR000GHSJK
1063  */
HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_004, testing::ext::TestSize.Level0)1064 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_004, testing::ext::TestSize.Level0)
1065 {
1066     // 1. set packName null
1067     std::string packName = "com.ohos.test";
1068     // set authParam null
1069     std::string netWorkId = "111";
1070     std::string udid = "222";
1071     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1072     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1073     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1074     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1075     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1076                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1077     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1078     int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
1079     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1080     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1081     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1082 }
1083 
1084 /**
1085  * @tc.name: GetUdidByNetworkId_005
1086  * @tc.desc: 1. set packName not null
1087  *                     set action null
1088  *                  2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1089  *                  3. call DeviceManagerImpl::SetUserOperation with parameter
1090  *                  4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1091  * deviceTypeId
1092  * @tc.type: FUNC
1093  * @tc.require: AR000GHSJK
1094  */
HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_005, testing::ext::TestSize.Level0)1095 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_005, testing::ext::TestSize.Level0)
1096 {
1097     // 1. set packName null
1098     std::string packName = "com.ohos.test";
1099     // set authParam null
1100     std::string netWorkId = "111";
1101     std::string udid = "222";
1102     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1103     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1104     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1105     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1106     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1107                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
1108     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1109     int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid);
1110     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1111     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1112     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1113 }
1114 
1115 /**
1116  * @tc.name: GetUuidByNetworkId_001
1117  * @tc.desc: 1. set packName null
1118  *              set action null
1119  *           2. call DeviceManagerImpl::SetUserOperation with parameter
1120  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1121  * deviceTypeId
1122  * @tc.type: FUNC
1123  * @tc.require: AR000GHSJK
1124  */
HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)1125 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)
1126 {
1127     // 1. set packName null
1128     std::string packName = "";
1129     // set authParam null
1130     std::string netWorkId = "111";
1131     std::string uuid = "222";
1132     // 2. call DeviceManagerImpl::SetUserOperation with parameter
1133     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1134     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1135     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1136 }
1137 
1138 /**
1139  * @tc.name: GetUuidByNetworkId_002
1140  * @tc.desc: 1. set packName not null
1141  *              set action null
1142  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1143  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1144  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1145  * deviceTypeId
1146  * @tc.type: FUNC
1147  * @tc.require: AR000GHSJK
1148  */
HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0)1149 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0)
1150 {
1151     // 1. set packName null
1152     std::string packName = "com.ohos.test";
1153     // set authParam null
1154     std::string netWorkId = "111";
1155     std::string uuid = "222";
1156     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
1157     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1158     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1159     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1160     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1161                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1162     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1163     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1164     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1165     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1166     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1167 }
1168 
1169 /**
1170  * @tc.name: GetUuidByNetworkId_003
1171  * @tc.desc: 1. set packName not null
1172  *              set action null
1173  *           2. MOCK IpcClientProxy SendRequest return DM_OK
1174  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1175  *           4. check ret is DM_OK
1176  * deviceTypeId
1177  * @tc.type: FUNC
1178  * @tc.require: AR000GHSJK
1179  */
HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0)1180 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0)
1181 {
1182     // 1. set packName not null
1183     std::string packName = "com.ohos.test";
1184     // set authParam null
1185     std::string netWorkId = "111";
1186     std::string uuid = "222";
1187     // 2. MOCK IpcClientProxy SendRequest return DM_OK
1188     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1189     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1190     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1191     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1192                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1193     // 3. call DeviceManagerImpl::GetUuidByNetworkId with parameter
1194     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1195     // 4. check ret is DM_OK
1196     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1197     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1198 }
1199 
1200 /**
1201  * @tc.name: GetUuidByNetworkId_004
1202  * @tc.desc: 1. set packName not null
1203  *              set action null
1204  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1205  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1206  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1207  * deviceTypeId
1208  * @tc.type: FUNC
1209  * @tc.require: AR000GHSJK
1210  */
HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_004, testing::ext::TestSize.Level0)1211 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_004, testing::ext::TestSize.Level0)
1212 {
1213     // 1. set packName null
1214     std::string packName = "com.ohos.test";
1215     // set authParam null
1216     std::string netWorkId = "111";
1217     std::string uuid = "222";
1218     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1219     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1220     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1221     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1222     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1223                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1224     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1225     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1226     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1227     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1228     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1229 }
1230 
1231 /**
1232  * @tc.name: GetUuidByNetworkId_005
1233  * @tc.desc: 1. set packName not null
1234  *                     set action null
1235  *                  2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1236  *                  3. call DeviceManagerImpl::SetUserOperation with parameter
1237  *                  4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1238  * deviceTypeId
1239  * @tc.type: FUNC
1240  * @tc.require: AR000GHSJK
1241  */
HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_005, testing::ext::TestSize.Level0)1242 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_005, testing::ext::TestSize.Level0)
1243 {
1244     // 1. set packName null
1245     std::string packName = "com.ohos.test";
1246     // set authParam null
1247     std::string netWorkId = "111";
1248     std::string uuid = "222";
1249     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1250     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1251     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1252     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1253     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1254                 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
1255     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1256     int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid);
1257     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1258     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1259     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1260 }
1261 
1262 /**
1263  * @tc.name: RegisterDeviceManagerFaCallback_001
1264  * @tc.desc: 1. set packName not null
1265  *              set action null
1266  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL
1267  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1268  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
1269  * deviceTypeId
1270  * @tc.type: FUNC
1271  * @tc.require: AR000GHSJK
1272  */
HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)1273 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)
1274 {
1275     // 1. set packName null
1276     std::string packName = "";
1277     // set callback null
1278     std::shared_ptr<DeviceManagerUiCallback> callback = nullptr;
1279     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1280     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1281     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1282     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1283 }
1284 
1285 /**
1286  * @tc.name: RegisterDeviceManagerFaCallback_002
1287  * @tc.desc: 1. set packName not null
1288  *              set callback not null
1289  *           2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1290  *           3. check ret is DM_OK
1291  * deviceTypeId
1292  * @tc.type: FUNC
1293  * @tc.require: AR000GHSJK
1294  */
HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)1295 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)
1296 {
1297     // 1. set packName null
1298     std::string packName = "com.ohos.test";
1299     // set callback null
1300     std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
1301     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1302     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1303     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1304     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1305     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1306                 .Times(1).WillOnce(testing::Return(DM_OK));
1307     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1308     // 3. check ret is DM_OK
1309     ASSERT_EQ(ret, DM_OK);
1310     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1311 }
1312 
1313 /**
1314  * @tc.name: RegisterDeviceManagerFaCallback_003
1315  * @tc.desc: 1. set packName not null
1316  *              set callback not null
1317  *           2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1318  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1319  * deviceTypeId
1320  * @tc.type: FUNC
1321  * @tc.require: AR000GHSJK
1322  */
HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)1323 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)
1324 {
1325     // 1. set packName null
1326     std::string packName = "com.ohos.test";
1327     // set callback null
1328     std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr;
1329     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1330     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1331     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1332     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1333 }
1334 
1335 /**
1336  * @tc.name: RegisterDeviceManagerFaCallback_004
1337  * @tc.desc: 1. set packName not null
1338  *              set callback not null
1339  *           2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1340  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1341  * deviceTypeId
1342  * @tc.type: FUNC
1343  * @tc.require: AR000GHSJK
1344  */
HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)1345 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)
1346 {
1347     // 1. set packName null
1348     std::string packName = "";
1349     // set callback null
1350     std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
1351     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1352     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1353     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1354     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1355 }
1356 
1357 /**
1358  * @tc.name: RegisterDeviceManagerFaCallback_005
1359  * @tc.desc: 1. set packName not null
1360  *              set callback not null
1361  *           2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1362  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1363  * deviceTypeId
1364  * @tc.type: FUNC
1365  * @tc.require: AR000GHSJK
1366  */
HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)1367 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)
1368 {
1369     // 1. set packName null
1370     std::string packName ("");
1371     // set callback null
1372     std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr;
1373     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1374     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback);
1375     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1376     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1377 }
1378 
1379 /**
1380  * @tc.name: UnRegisterDeviceManagerFaCallback_001
1381  * @tc.desc: 1. set packName null
1382  *           2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter
1383  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1384  * deviceTypeId
1385  * @tc.type: FUNC
1386  * @tc.require: AR000GHSJK
1387  */
HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)1388 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0)
1389 {
1390     // 1. set packName null
1391     std::string packName = "";
1392     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1393     int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName);
1394     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1395     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1396 }
1397 
1398 /**
1399  * @tc.name: UnRegisterDeviceManagerFaCallback_002
1400  * @tc.desc: 1. set packName not null
1401  *           2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter
1402  *           3. check ret is DM_OK
1403  * deviceTypeId
1404  * @tc.type: FUNC
1405  * @tc.require: AR000GHSJK
1406  */
HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)1407 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0)
1408 {
1409     // 1. set packName null
1410     std::string packName = "com.ohos.test";
1411     // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter
1412     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1413     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1414     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1415     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1416                 .Times(1).WillOnce(testing::Return(DM_OK));
1417     int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName);
1418     // 3. check ret is DM_OK
1419     ASSERT_EQ(ret, DM_OK);
1420     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1421 }
1422 
1423 /**
1424  * @tc.name: UnRegisterDeviceManagerFaCallback_003
1425  * @tc.desc: 1. set packName not null
1426  *              set callback not null
1427  *           2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
1428  *           3. check ret is DM_OK
1429  *           4. set checkMap null
1430  *           5. Get checkMap from DeviceManagerNotify
1431  *           6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1432  *           7. Get checkMap from pkgName
1433  *           8. check checkMap null
1434  * deviceTypeId
1435  * @tc.type: FUNC
1436  * @tc.require: AR000GHSJK
1437  */
HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)1438 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0)
1439 {
1440     // 1. set pkgName not null
1441     std::string pkgName = "com.ohos.test";
1442     // set callback not null
1443     std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
1444     // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
1445     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1446     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1447     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1448     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1449                 .Times(1).WillOnce(testing::Return(DM_OK));
1450     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
1451     // 3. check ret is DM_OK
1452     ASSERT_EQ(ret, DM_OK);
1453     // 4. set checkMap null
1454     std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
1455     // 5. Get checkMap from DeviceManagerNotify
1456     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1457     // 5. check checkMap not null
1458     ASSERT_NE(checkMap, nullptr);
1459     // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1460     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1461                 .Times(1).WillOnce(testing::Return(DM_OK));
1462     DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(pkgName);
1463     // 7. Get checkMap from pkgName
1464     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1465     // 8 check checkMap null
1466     ASSERT_EQ(checkMap, nullptr);
1467     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1468 }
1469 
1470 /**
1471  * @tc.name: UnRegisterDeviceManagerFaCallback_004
1472  * @tc.desc: 1. set packName not null
1473  *              set callback not null
1474  *           2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
1475  *           3. check ret is DM_OK
1476  *           4. set checkMap null
1477  *           5. Get checkMap from DeviceManagerNotify
1478  *           6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1479  *           7. Get checkMap from pkgName
1480  *           8. check checkMap null
1481  * deviceTypeId
1482  * @tc.type: FUNC
1483  * @tc.require: AR000GHSJK
1484  */
HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)1485 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0)
1486 {
1487     // 1. set pkgName not null
1488     std::string pkgName = "com.ohos.test";
1489     // set callback not null
1490     std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>();
1491     // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter
1492     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1493     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1494     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1495     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1496                 .Times(1).WillOnce(testing::Return(DM_OK));
1497     int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
1498     // 3. check ret is DM_OK
1499     ASSERT_EQ(ret, DM_OK);
1500     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1501     // 4. set checkMap null
1502     std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
1503     // 5. Get checkMap from DeviceManagerNotify
1504     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1505     // 5. check checkMap not null
1506     ASSERT_NE(checkMap, nullptr);
1507     // 6. set unRegisterPkgNamr different from pkgName
1508     std::string unRegisterPkgName = "com.ohos.test1";
1509     // 7. call DeviceManager UnRegisterDeviceManagerFaCallback with unRegisterPkgName
1510     DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName);
1511     // 7. Get checkMap from pkgName
1512     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1513     // 8 check checkMap not null
1514     ASSERT_NE(checkMap, nullptr);
1515 }
1516 
1517 /**
1518  * @tc.name: UnRegisterDeviceManagerFaCallback_005
1519  * @tc.desc: 1. set packName not null
1520  *           2. Set checkMap null
1521  *           3. Get checkMap from DeviceManagerNotify
1522  *           4. check checkMap not null
1523  *           5. Set unRegisterPkgName is different from register pkgName
1524  *           6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1525  *           7. Get checkMap from DeviceManagerNotify
1526  *           8. check checkMap not null
1527  * deviceTypeId
1528  * @tc.type: FUNC
1529  * @tc.require: AR000GHSJK
1530  */
HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)1531 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0)
1532 {
1533     // 1. set pkgName not null
1534     std::string pkgName = "com.ohos.test";
1535     // 2. Set checkMap null
1536     std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr;
1537     // 3. Get checkMap from DeviceManagerNotify
1538     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1539     // 4. check checkMap not null
1540     ASSERT_NE(checkMap, nullptr);
1541     // 5. Set unRegisterPkgName is different from register pkgName
1542     std::string unRegisterPkgName = "com.ohos.test1";
1543     // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter
1544     DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName);
1545     // 7. Get checkMap from DeviceManagerNotify
1546     checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName];
1547     // 8. check checkMap not null
1548     ASSERT_NE(checkMap, nullptr);
1549 }
1550 } // namespace
1551 } // namespace DistributedHardware
1552 } // namespace OHOS