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
31namespace OHOS {
32namespace DistributedHardware {
33void IpcClientManagerTest::SetUp()
34{
35}
36
37void IpcClientManagerTest::TearDown()
38{
39}
40
41void IpcClientManagerTest::SetUpTestCase()
42{
43}
44
45void IpcClientManagerTest::TearDownTestCase()
46{
47}
48
49namespace {
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 */
59HWTEST_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 */
89HWTEST_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 */
113HWTEST_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 */
132HWTEST_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 */
156HWTEST_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 */
182HWTEST_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 */
208HWTEST_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 */
234HWTEST_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 */
260HWTEST_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 */
284HWTEST_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 */
316HWTEST_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 */
348HWTEST_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 */
380HWTEST_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 */
410HWTEST_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 */
437HWTEST_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 */
472HWTEST_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 */
507HWTEST_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 */
542HWTEST_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 */
570HWTEST_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 */
586HWTEST_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 */
602HWTEST_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 */
617HWTEST_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 */
636HWTEST_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 */
654HWTEST_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 */
674HWTEST_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
690DmInitCallbackTest::DmInitCallbackTest(int &count) : DmInitCallback()
691{
692    count_ = &count;
693}
694
695void DmInitCallbackTest::OnRemoteDied()
696{
697     *count_ = *count_ + 1;
698}
699} // namespace DistributedHardware
700} // namespace OHOS
701