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