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_ipc_client_manager.h"
17 
18 #include "device_manager_ipc_interface_code.h"
19 #include "device_manager_notify.h"
20 #include "dm_device_info.h"
21 #include "ipc_client_stub.h"
22 #include "ipc_register_listener_req.h"
23 #include "ipc_remote_broker.h"
24 #include "iremote_object.h"
25 #include "iservice_registry.h"
26 #include "dm_constants.h"
27 #include "system_ability_definition.h"
28 
29 #include <unistd.h>
30 
31 namespace OHOS {
32 namespace DistributedHardware {
SetUp()33 void IpcClientManagerTest::SetUp()
34 {
35 }
36 
TearDown()37 void IpcClientManagerTest::TearDown()
38 {
39 }
40 
SetUpTestCase()41 void IpcClientManagerTest::SetUpTestCase()
42 {
43 }
44 
TearDownTestCase()45 void IpcClientManagerTest::TearDownTestCase()
46 {
47 }
48 
49 namespace {
50     /**
51  * @tc.name: OnRemoteDied_001
52  * @tc.desc: 1. new a dmInterface
53  *           2. set IpcClientManager dmInterface_ not null
54  *           3. call ClientInit
55  *           4. check ret is DM_OK
56  * @tc.type: FUNC
57  * @tc.require: AR000GHSJK
58  */
59 HWTEST_F(IpcClientManagerTest, OnRemoteDied_001, testing::ext::TestSize.Level0)
60 {
61     // 1. set pkgName not null
62     std::string pkgName = "com.ohos.test";
63     // set dmInitCallback not null
64     int count = 0;
65     std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count);
66     // 2. set checkMap null
67     std::shared_ptr<DmInitCallback> checkMap = nullptr;
68     // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter
69     DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
70     // 4. Get checkMap from DeviceManagerNotify
71     checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName];
72     // 5. check checkMap not null
73     ASSERT_NE(checkMap, nullptr);
74     // 6. call DeviceManagerNotify OnRemoteDied
75     DeviceManagerNotify::GetInstance().OnRemoteDied();
76     // 7. check if dmInitCallback OnRemoteDied called
77     ASSERT_EQ(count, 1);
78 }
79 
80 /**
81  * @tc.name: ClientInit_001
82  * @tc.desc: 1. new a dmInterface
83  *           2. set IpcClientManager dmInterface_ not null
84  *           3. call ClientInit
85  *           4. check ret is not ERR_DM_FAILED
86  * @tc.type: FUNC
87  * @tc.require: AR000GHSJK
88  */
89 HWTEST_F(IpcClientManagerTest, ClientInit_001, testing::ext::TestSize.Level0)
90 {
91     // 1. new a dmInterface
92     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
93     auto object = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
94     sptr<IpcRemoteBroker> dmInterface = iface_cast<IpcRemoteBroker>(object);
95     // 2. set IpcClientManager dmInterface_ not null
96     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
97     instance->dmInterface_ = dmInterface;
98     // 3. call ClientInit
99     int ret = instance->ClientInit();
100     // 4. check ret is not ERR_DM_FAILED
101     ASSERT_NE(ret, ERR_DM_FAILED);
102 }
103 
104 /**
105  * @tc.name: ClientInit_002
106  * @tc.desc: 1. new a dmInterface
107  *           2. set IpcClientManager dmInterface_ not null
108  *           3. call ClientInit
109  *           4. check ret is not ERR_DM_FAILED
110  * @tc.type: FUNC
111  * @tc.require: AR000GHSJK
112  */
113 HWTEST_F(IpcClientManagerTest, ClientInit_002, testing::ext::TestSize.Level0)
114 {
115     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
116     // 3. call ClientInit
117     int ret = instance->ClientInit();
118     // 4. check ret is not ERR_DM_FAILED
119     ASSERT_NE(ret, ERR_DM_FAILED);
120 }
121 
122 /**
123  * @tc.name: Init_001
124  * @tc.desc: 1. new a listener
125  *           2. set a pkgName not null
126  *           3. add listener and pkgName in dmListener_ Map
127  *           4. call Init with pkgName
128  *           5. check ret is not ERR_DM_FAILED
129  * @tc.type: FUNC
130  * @tc.require: AR000GHSJK
131  */
132 HWTEST_F(IpcClientManagerTest, Init_001, testing::ext::TestSize.Level0)
133 {
134     // 1. new a listener
135     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
136     // 2. set a pkgName not null
137     std::string pkgName = "com.ohos.test";
138     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
139     // 3. add listener and pkgName in dmListener_ Map
140     instance->dmListener_[pkgName] = listener;
141     // 4. call Init with pkgName
142     int32_t ret = instance->Init(pkgName);
143     // 5. check ret is not ERR_DM_FAILED
144     ASSERT_NE(ret, ERR_DM_FAILED);
145 }
146 
147 /**
148  * @tc.name: Init_002
149  * @tc.desc: 1. set pkcName not null
150  *           2. Mock IpcClientServerProxy SendCmd return ERR_DM_FAILED
151  *           3. call Init with pkgName
152  *           4. check ret is ERR_DM_FAILED
153  * @tc.type: FUNC
154  * @tc.require: AR000GHSJK
155  */
156 HWTEST_F(IpcClientManagerTest, Init_002, testing::ext::TestSize.Level0)
157 {
158     // 1. set pkcName not null
159     std::string pkgName = "com.ohos.test";
160     // 2. Mock IpcClientServerProxy SendCmd return ERR_DM_FAILED
161     sptr<IRemoteObject> remoteObject = nullptr;
162     auto mockInstance = new MockIpcClientManager(remoteObject);
163     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
164     instance->dmInterface_ = mockInstance;
165     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
166                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
167     // 3. call Init with pkgName
168     int32_t ret = instance->Init(pkgName);
169     // 4. check ret is ERR_DM_FAILED
170     ASSERT_EQ(ret, ERR_DM_FAILED);
171 }
172 
173 /**
174  * @tc.name: Init_003
175  * @tc.desc: 1. set pkcName not null
176  *           2. Mock IpcClientServerProxy SendCmd return DM_OK
177  *           3. call Init with pkgName
178  *           4. check ret is DM_OK
179  * @tc.type: FUNC
180  * @tc.require: AR000GHSJK
181  */
182 HWTEST_F(IpcClientManagerTest, Init_003, testing::ext::TestSize.Level0)
183 {
184     // 1. set pkcName not null
185     std::string pkgName = "com.ohos.test";
186     // 2. Mock IpcClientServerProxy SendCmd return DM_OK
187     sptr<IRemoteObject> remoteObject = nullptr;
188     auto mockInstance = new MockIpcClientManager(remoteObject);
189     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
190     instance->dmInterface_ = mockInstance;
191     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
192                 .Times(1).WillOnce(testing::Return(DM_OK));
193     // 3. call Init with pkgName
194     int32_t ret = instance->Init(pkgName);
195     // 4. check ret is DM_OK
196     ASSERT_EQ(ret, DM_OK);
197 }
198 
199 /**
200  * @tc.name: Init_004
201  * @tc.desc: 1. set pkcName not null
202  *           2. Mock IpcClientServerProxy SendCmd return DM_OK
203  *           3. call Init with pkgName
204  *           4. check ret is DM_OK
205  * @tc.type: FUNC
206  * @tc.require: AR000GHSJK
207  */
208 HWTEST_F(IpcClientManagerTest, Init_004, testing::ext::TestSize.Level0)
209 {
210     // 1. set pkcName not null
211     std::string pkgName = "com.ohos.test";
212     // 2. Mock IpcClientServerProxy SendCmd return DEVICEMANAGER_SERVICE_NOT_READY
213     sptr<IRemoteObject> remoteObject = nullptr;
214     auto mockInstance = new MockIpcClientManager(remoteObject);
215     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
216     instance->dmInterface_ = mockInstance;
217     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
218                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
219     // 3. call Init with pkgName
220     int32_t ret = instance->Init(pkgName);
221     // 4. check ret is DEVICEMANAGER_OK
222     ASSERT_EQ(ret, ret);
223 }
224 
225 /**
226  * @tc.name: Init_005
227  * @tc.desc:  1. set pkcName not null
228  *            2. Mock IpcClientServerProxy SendCmd return ERR_DM_IPC_RESPOND_FAILED
229  *            3. call Init with pkgName
230  *            4. check ret is ERR_DM_IPC_RESPOND_FAILED
231  * @tc.type: FUNC
232  * @tc.require: AR000GHSJK
233  */
234 HWTEST_F(IpcClientManagerTest, Init_005, testing::ext::TestSize.Level0)
235 {
236     // 1. set pkcName not null
237     std::string pkgName = "com.ohos.test";
238     // 2. Mock IpcClientServerProxy SendCmd return DM_OK
239     sptr<IRemoteObject> remoteObject = nullptr;
240     auto mockInstance = new MockIpcClientManager(remoteObject);
241     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
242     instance->dmInterface_ = mockInstance;
243     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
244                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_RESPOND_FAILED));
245     // 3. call Init with pkgName
246     int32_t ret = instance->Init(pkgName);
247     // 4. check ret is ERR_DM_IPC_RESPOND_FAILED
248     ASSERT_EQ(ret, ERR_DM_IPC_RESPOND_FAILED);
249 }
250 
251 /**
252  * @tc.name: UnInit_001
253  * @tc.desc:  1. set pkgName null
254  *               set IpcClientManager dmInterface_ null
255  *            2. call UnInit with pkgName
256  *            3. check ret is ERR_DM_INPUT_PARA_INVALID
257  * @tc.type: FUNC
258  * @tc.require: AR000GHSJK
259  */
260 HWTEST_F(IpcClientManagerTest, UnInit1, testing::ext::TestSize.Level0)
261 {
262     // 1. set pkgName null
263     std::string pkgName;
264     // set IpcClientManager dmInterface_ null
265     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
266     instance->dmInterface_ = nullptr;
267     // 2. call UnInit with pkgName
268     int32_t ret = instance->UnInit(pkgName);
269     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
270     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
271 }
272 
273 /**
274  * @tc.name: UnInit_002
275  * @tc.desc:  1. set pkgName not null
276  *            2. Mock IpcClientServerProxy SendCmd return ERR_DM_FAILED
277  *            3. set IpcClientManager dmInterface_ not null
278  *            4. set IpcClientManager dmListener_ not null
279  *            5. call UnInit with pkgName
280  *            6. check ret is ERR_DM_FAILED
281  * @tc.type: FUNC
282  * @tc.require: AR000GHSJK
283  */
284 HWTEST_F(IpcClientManagerTest, UnInit_002, testing::ext::TestSize.Level0)
285 {
286     // 1. set pkgName not null
287     std::string pkgName = "com.ohos.test";
288     // 2. Mock IpcClientServerProxy SendCmd return ERR_DM_FAILED
289     sptr<IRemoteObject> remoteObject = nullptr;
290     auto mockInstance = new MockIpcClientManager(remoteObject);
291     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
292                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
293     // 3. set IpcClientManager dmInterface_ not null
294     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
295     instance->dmInterface_ = mockInstance;
296     // 4. set IpcClientManager dmListener_ not null
297     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
298     instance->dmListener_[pkgName] = listener;
299     // 5. call UnInit with pkgName
300     int32_t ret = instance->UnInit(pkgName);
301     // 6. check ret is ERR_DM_FAILED
302     ASSERT_EQ(ret, ERR_DM_FAILED);
303 }
304 
305 /**
306  * @tc.name: UnInit_003
307  * @tc.desc:  1. set pkgName not null
308  *            2. Mock IpcClientServerProxy SendCmd return DM_OK
309  *            3. set IpcClientManager dmInterface_ not null
310  *            4. set IpcClientManager dmListener_ not null
311  *            5. call UnInit with pkgName
312  *            6. check ret is DM_OK
313  * @tc.type: FUNC
314  * @tc.require: AR000GHSJK
315  */
316 HWTEST_F(IpcClientManagerTest, UnInit_003, testing::ext::TestSize.Level0)
317 {
318     // 1. set pkgName not null
319     std::string pkgName = "com.ohos.test";
320     // 2. Mock IpcClientServerProxy SendCmd return DM_OK
321     sptr<IRemoteObject> remoteObject = nullptr;
322     auto mockInstance = new MockIpcClientManager(remoteObject);
323     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
324                 .Times(1).WillOnce(testing::Return(DM_OK));
325     // 3. set IpcClientManager dmInterface_ not null
326     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
327     instance->dmInterface_ = mockInstance;
328     // 4. set IpcClientManager dmListener_ not null
329     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
330     instance->dmListener_[pkgName] = listener;
331     // 5. call UnInit with pkgName
332     int32_t ret = instance->UnInit(pkgName);
333     // 6. check ret is DM_OK
334     ASSERT_EQ(ret, DM_OK);
335 }
336 
337 /**
338  * @tc.name: UnInit_004
339  * @tc.desc:  1. set pkgName not null
340  *            2. Mock IpcClientServerProxy SendCmd return ERR_DM_INIT_FAILED
341  *            3. set IpcClientManager dmInterface_ not null
342  *            4. set IpcClientManager dmListener_ not null
343  *            5. call UnInit with pkgName
344  *            6. check ret is ERR_DM_INIT_FAILED
345  * @tc.type: FUNC
346  * @tc.require: AR000GHSJK
347  */
348 HWTEST_F(IpcClientManagerTest, UnInit_004, testing::ext::TestSize.Level0)
349 {
350     // 1. set pkgName not null
351     std::string pkgName = "com.ohos.test";
352     // 2. Mock IpcClientServerProxy SendCmd return ERR_DM_INIT_FAILED
353     sptr<IRemoteObject> remoteObject = nullptr;
354     auto mockInstance = new MockIpcClientManager(remoteObject);
355     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
356                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
357     // 3. set IpcClientManager dmInterface_ not null
358     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
359     instance->dmInterface_ = mockInstance;
360     // 4. set IpcClientManager dmListener_ not null
361     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
362     instance->dmListener_[pkgName] = listener;
363     // 5. call UnInit with pkgName
364     int32_t ret = instance->UnInit(pkgName);
365     // 6. check ret is ERR_DM_INIT_FAILED
366     ASSERT_EQ(ret, ERR_DM_INIT_FAILED);
367 }
368 
369 /**
370  * @tc.name: UnInit_005
371  * @tc.desc:  1. set pkgName not null
372  *            2. Mock IpcClientServerProxy SendCmd return ERR_DM_IPC_SEND_REQUEST_FAILED
373  *            3. set IpcClientManager dmInterface_ not null
374  *            4. set IpcClientManager dmListener_ not null
375  *            5. call UnInit with pkgName
376  *            6. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
377  * @tc.type: FUNC
378  * @tc.require: AR000GHSJK
379  */
380 HWTEST_F(IpcClientManagerTest, UnInit_005, testing::ext::TestSize.Level0)
381 {
382     // 1. set pkgName not null
383     std::string pkgName = "com.ohos.test";
384     // 2. Mock IpcClientServerProxy SendCmd return ERR_DM_IPC_SEND_REQUEST_FAILED
385     sptr<IRemoteObject> remoteObject = nullptr;
386     auto mockInstance = new MockIpcClientManager(remoteObject);
387     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
388                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
389     // 3. set IpcClientManager dmInterface_ not null
390     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
391     instance->dmInterface_ = mockInstance;
392     // 4. set IpcClientManager dmListener_ not null
393     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
394     instance->dmListener_[pkgName] = listener;
395     // 5. call UnInit with pkgName
396     int32_t ret = instance->UnInit(pkgName);
397     // 6. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
398     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
399 }
400 
401 /**
402  * @tc.name: SendRequest_001
403  * @tc.desc:  1. set pkgName null
404  *            2. set IpcClientManager dmInterface_null
405  *            3. call SendRequest with parameter
406  *            4. check ret is ERR_DM_INIT_FAILED
407  * @tc.type: FUNC
408  * @tc.require: AR000GHSJK
409  */
410 HWTEST_F(IpcClientManagerTest, SendRequest_001, testing::ext::TestSize.Level0)
411 {
412     // 1. set pkgName null
413     std::string pkgName = "";
414     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
415     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
416     req->SetPkgName(pkgName);
417     // 2. set IpcClientManager dmInterface_null
418     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
419     instance->dmInterface_ = nullptr;
420     // 3. call SendRequest with parameter
421     int ret = instance->SendRequest(0, req, rsp);
422     // 4. check ret is ERR_DM_INIT_FAILED
423     ASSERT_EQ(ret, ERR_DM_INIT_FAILED);
424 }
425 
426 /**
427  * @tc.name: SendRequest_002
428  * @tc.desc:  1. set pkgName not null
429  *            2. Mock IpcClientServerProxy SendCmd return ERR_DM_FAILED
430  *            3. set IpcClientManager dmInterface_ not null
431  *            4. set IpcClientManager dmListener_ not null
432  *            5. call SendRequest with parameter
433  *            6. check ret is ERR_DM_FAILED
434  * @tc.type: FUNC
435  * @tc.require: AR000GHSJK
436  */
437 HWTEST_F(IpcClientManagerTest, SendRequest_002, testing::ext::TestSize.Level0)
438 {
439     // 1. set pkgName not null
440     std::string pkgName = "com.ohos.test";
441     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
442     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
443     req->SetPkgName(pkgName);
444     // 2. Mock IpcClientServerProxy SendCmd return ERR_DM_FAILED
445     sptr<IRemoteObject> remoteObject = nullptr;
446     auto mockInstance = new MockIpcClientManager(remoteObject);
447     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
448                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
449     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
450     // 3. set IpcClientManager dmInterface_ not null
451     instance->dmInterface_ = mockInstance;
452     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
453     // 4. set IpcClientManager dmListener_ not null
454     instance->dmListener_[pkgName] = listener;
455     // 5. call SendRequest with parameter
456     int ret = instance->SendRequest(0, req, rsp);
457     // 6. check ret is ERR_DM_FAILED
458     ASSERT_EQ(ret, ERR_DM_FAILED);
459 }
460 
461 /**
462  * @tc.name: SendRequest_003
463  * @tc.desc:  1. set pkgName not null
464  *            2. Mock IpcClientServerProxy SendCmd return DM_OK
465  *            3. set IpcClientManager dmInterface_ not null
466  *            4. set IpcClientManager dmListener_ not null
467  *            5. call SendRequest with parameter
468  *            6. check ret is DM_OK
469  * @tc.type: FUNC
470  * @tc.require: AR000GHSJK
471  */
472 HWTEST_F(IpcClientManagerTest, SendRequest_003, testing::ext::TestSize.Level0)
473 {
474     // 1. set pkgName not null
475     std::string pkgName = "com.ohos.test";
476     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
477     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
478     req->SetPkgName(pkgName);
479     // 2. Mock IpcClientServerProxy SendCmd return DM_OK
480     sptr<IRemoteObject> remoteObject = nullptr;
481     auto mockInstance = new MockIpcClientManager(remoteObject);
482     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
483                 .Times(1).WillOnce(testing::Return(DM_OK));
484     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
485     // 3. set IpcClientManager dmInterface_ not null
486     instance->dmInterface_ = mockInstance;
487     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
488     // 4. set IpcClientManager dmListener_ not null
489     instance->dmListener_[pkgName] = listener;
490     // 5. call SendRequest with parameter
491     int ret = instance->SendRequest(0, req, rsp);
492     // 6. check ret is DM_OK
493     ASSERT_EQ(ret, DM_OK);
494 }
495 
496 /**
497  * @tc.name: SendRequest_004
498  * @tc.desc:  1. set pkgName not null
499  *            2. Mock IpcClientServerProxy SendCmd return ERR_DM_INIT_FAILED
500  *            3. set IpcClientManager dmInterface_ not null
501  *            4. set IpcClientManager dmListener_ not null
502  *            5. call SendRequest with parameter
503  *            6. check ret is ERR_DM_INIT_FAILED
504  * @tc.type: FUNC
505  * @tc.require: AR000GHSJK
506  */
507 HWTEST_F(IpcClientManagerTest, SendRequest_004, testing::ext::TestSize.Level0)
508 {
509     // 1. set pkgName not null
510     std::string pkgName = "com.ohos.test";
511     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
512     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
513     req->SetPkgName(pkgName);
514     // 2. Mock IpcClientServerProxy SendCmd return ERR_DM_INIT_FAILED
515     sptr<IRemoteObject> remoteObject = nullptr;
516     auto mockInstance = new MockIpcClientManager(remoteObject);
517     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
518                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
519     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
520     // 3. set IpcClientManager dmInterface_ not null
521     instance->dmInterface_ = mockInstance;
522     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
523     // 4. set IpcClientManager dmListener_ not null
524     instance->dmListener_[pkgName] = listener;
525     // 5. call SendRequest with parameter
526     int ret = instance->SendRequest(0, req, rsp);
527     // 6. check ret is ERR_DM_INIT_FAILED
528     ASSERT_EQ(ret, ERR_DM_INIT_FAILED);
529 }
530 
531 /**
532  * @tc.name: SendRequest_005
533  * @tc.desc:  1. set pkgName not null
534  *            2. Mock IpcClientServerProxy SendCmd return ERR_DM_IPC_SEND_REQUEST_FAILED
535  *            3. set IpcClientManager dmInterface_ not null
536  *            4. set IpcClientManager dmListener_ not null
537  *            5. call SendRequest with parameter
538  *            6. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
539  * @tc.type: FUNC
540  * @tc.require: AR000GHSJK
541  */
542 HWTEST_F(IpcClientManagerTest, SendRequest_005, testing::ext::TestSize.Level0)
543 {
544     // 1. set pkgName not null
545     std::string pkgName = "com.ohos.test";
546     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
547     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
548     req->SetPkgName(pkgName);
549     // 2. Mock IpcClientServerProxy SendCmd return ERR_DM_IPC_SEND_REQUEST_FAILED
550     sptr<IRemoteObject> remoteObject = nullptr;
551     auto mockInstance = new MockIpcClientManager(remoteObject);
552     EXPECT_CALL(*mockInstance, SendCmd(testing::_, testing::_, testing::_))
553                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
554     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
555     // 3. set IpcClientManager dmInterface_ not null
556     instance->dmInterface_ = mockInstance;
557     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
558     // 4. set IpcClientManager dmListener_ not null
559     instance->dmListener_[pkgName] = listener;
560     // 5. call SendRequest with parameter
561     int ret = instance->SendRequest(0, req, rsp);
562     // 6. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
563     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
564 }
565 
566 /**
567  * @tc.name: SendRequest_006
568  * @tc.type: FUNC
569  */
570 HWTEST_F(IpcClientManagerTest, SendRequest_006, testing::ext::TestSize.Level0)
571 {
572     std::string pkgName = "com.ohos.test";
573     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
574     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
575     req->SetPkgName(pkgName);
576     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
577     instance->dmInterface_ = nullptr;
578     int ret = instance->SendRequest(IPC_MSG_BUTT, req, rsp);
579     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
580 }
581 
582 /**
583  * @tc.name: SendRequest_007
584  * @tc.type: FUNC
585  */
586 HWTEST_F(IpcClientManagerTest, SendRequest_007, testing::ext::TestSize.Level0)
587 {
588     std::string pkgName = "com.ohos.test";
589     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
590     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
591     req->SetPkgName(pkgName);
592     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
593     instance->dmInterface_ = nullptr;
594     int ret = instance->SendRequest(-1, req, rsp);
595     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
596 }
597 
598 /**
599  * @tc.name: SendRequest_008
600  * @tc.type: FUNC
601  */
602 HWTEST_F(IpcClientManagerTest, SendRequest_008, testing::ext::TestSize.Level0)
603 {
604     std::string pkgName = "com.ohos.test";
605     std::shared_ptr<IpcReq> req = nullptr;
606     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
607     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
608     instance->dmInterface_ = nullptr;
609     int ret = instance->SendRequest(0, req, rsp);
610     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
611 }
612 
613 /**
614  * @tc.name: SendRequest_009
615  * @tc.type: FUNC
616  */
617 HWTEST_F(IpcClientManagerTest, SendRequest_009, testing::ext::TestSize.Level0)
618 {
619     std::string pkgName = "";
620     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
621     std::shared_ptr<IpcRsp> rsp = nullptr;
622     req->SetPkgName(pkgName);
623     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
624     instance->dmInterface_ = nullptr;
625     int ret = instance->SendRequest(0, req, rsp);
626     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
627 }
628 
629 /**
630  * @tc.name: OnDmServiceDied_001
631  * @tc.desc: 1. set IpcClientManager dmInterface_null
632  *           2. call OnDmServiceDied
633  *           3. check ret is ERR_DM_POINT_NULL
634  * @tc.type: FUNC
635  */
636 HWTEST_F(IpcClientManagerTest, OnDmServiceDied_001, testing::ext::TestSize.Level0)
637 {
638     // 1. set IpcClientManager dmInterface_null
639     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
640     instance->dmInterface_ = nullptr;
641     // 2. call OnDmServiceDied
642     int32_t ret = instance->OnDmServiceDied();
643     // 3. check ret is false
644     ASSERT_EQ(ret, ERR_DM_POINT_NULL);
645 }
646 
647 /**
648  * @tc.name: OnDmServiceDied_002
649  * @tc.desc: 1. set IpcClientManager dmInterface_null
650  *           3. call OnDmServiceDied
651  *           4. check ret is DM_OK
652  * @tc.type: FUNC
653  */
654 HWTEST_F(IpcClientManagerTest, OnDmServiceDied_002, testing::ext::TestSize.Level0)
655 {
656     // 1. set IpcClientManager dmInterface_null
657     sptr<IRemoteObject> remoteObject = nullptr;
658     auto mockInstance = new MockIpcClientManager(remoteObject);
659     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
660     instance->dmInterface_ = mockInstance;
661     // 2. call OnDmServiceDied
662     int32_t ret = instance->OnDmServiceDied();
663     // 3. check ret is DM_OK
664     ASSERT_EQ(ret, DM_OK);
665 }
666 
667 /**
668  * @tc.name: OnDmServiceDied_003
669  * @tc.desc: 1. set IpcClientManager dmInterface_null
670  *           3. call OnDmServiceDied
671  *           4. check ret is DM_OK
672  * @tc.type: FUNC
673  */
674 HWTEST_F(IpcClientManagerTest, OnDmServiceDied_003, testing::ext::TestSize.Level0)
675 {
676     // 1. set IpcClientManager dmInterface_null
677     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
678     auto object = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
679     sptr<IpcRemoteBroker> dmInterface = iface_cast<IpcRemoteBroker>(object);
680     std::shared_ptr<IpcClientManager> instance = std::make_shared<IpcClientManager>();
681     instance->dmInterface_ = dmInterface;
682     instance->dmRecipient_ = sptr<DmDeathRecipient>(new DmDeathRecipient());
683     // 2. call OnDmServiceDied
684     int32_t ret = instance->OnDmServiceDied();
685     // 3. check ret is DM_OK
686     ASSERT_EQ(ret, DM_OK);
687 }
688 } // namespace
689 
DmInitCallbackTest(int & count)690 DmInitCallbackTest::DmInitCallbackTest(int &count) : DmInitCallback()
691 {
692     count_ = &count;
693 }
694 
OnRemoteDied()695 void DmInitCallbackTest::OnRemoteDied()
696 {
697      *count_ = *count_ + 1;
698 }
699 } // namespace DistributedHardware
700 } // namespace OHOS
701