1 /*
2 * Copyright (c) 2021 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_server_stub.h"
17 #include "dm_device_info.h"
18 #include "ipc_server_stub.h"
19 #include "device_manager_impl.h"
20 #include "dm_constants.h"
21 #include "if_system_ability_manager.h"
22 #include "ipc_cmd_register.h"
23 #include "ipc_skeleton.h"
24 #include "ipc_types.h"
25 #include "iservice_registry.h"
26 #include "string_ex.h"
27 #include "system_ability_definition.h"
28
29 #include <algorithm>
30 #include <thread>
31 #include <unistd.h>
32
33 namespace OHOS {
34 namespace DistributedHardware {
SetUp()35 void IpcServerStubTest::SetUp()
36 {
37 }
38
TearDown()39 void IpcServerStubTest::TearDown()
40 {
41 }
42
SetUpTestCase()43 void IpcServerStubTest::SetUpTestCase()
44 {
45 }
46
TearDownTestCase()47 void IpcServerStubTest::TearDownTestCase()
48 {
49 }
50
51 namespace {
52 /**
53 * @tc.name: OnStart_001
54 * @tc.desc: 1. Call IpcServerStub OnStart
55 * 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
56 * @tc.type: FUNC
57 * @tc.require: AR000GHSJK
58 */
59 HWTEST_F(IpcServerStubTest, OnStart_001, testing::ext::TestSize.Level0)
60 {
61 // 1. Call IpcServerStub OnStart
62 IpcServerStub::GetInstance().OnStart();
63 // 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
64 ASSERT_EQ(ServiceRunningState::STATE_RUNNING, IpcServerStub::GetInstance().state_);
65 }
66
67 /**
68 * @tc.name: OnStart_002
69 * @tc.desc: 1. set IpcServerStub state is ServiceRunningState::STATE_RUNNING
70 * 2. Call IpcServerStub OnStart
71 * 3. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
72 * @tc.type: FUNC
73 * @tc.require: AR000GHSJK
74 */
75 HWTEST_F(IpcServerStubTest, OnStart_002, testing::ext::TestSize.Level0)
76 {
77 // 1. set IpcServerStub state is ServiceRunningState::STATE_RUNNING
78 IpcServerStub::GetInstance().state_ = ServiceRunningState::STATE_RUNNING;
79 // 2. Call IpcServerStub OnStart
80 IpcServerStub::GetInstance().OnStart();
81 // 3. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
82 ASSERT_EQ(ServiceRunningState::STATE_RUNNING, IpcServerStub::GetInstance().state_);
83 }
84
85 /**
86 * @tc.name: Init_001
87 * @tc.desc: 1. Call IpcServerStub OnStart
88 * 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
89 * @tc.type: FUNC
90 * @tc.require: AR000GHSJK
91 */
92 HWTEST_F(IpcServerStubTest, Init_001, testing::ext::TestSize.Level0)
93 {
94 IpcServerStub::GetInstance().registerToService_=true;
95 bool result = IpcServerStub::GetInstance().Init();
96 // 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
97 ASSERT_EQ(result, true);
98 }
99
100 /**
101 * @tc.name: Init_002
102 * @tc.desc: 1. Call IpcServerStub OnStart
103 * 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
104 * @tc.type: FUNC
105 * @tc.require: AR000GHSJK
106 */
107 HWTEST_F(IpcServerStubTest, Init_002, testing::ext::TestSize.Level0)
108 {
109 IpcServerStub::GetInstance().registerToService_=false;
110 bool result = IpcServerStub::GetInstance().Init();
111 // 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
112 ASSERT_EQ(result, true);
113 }
114
115 /**
116 * @tc.name: OnStop_001
117 * @tc.desc: 1. Call IpcServerStub OnStop
118 * 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
119 * @tc.type: FUNC
120 * @tc.require: AR000GHSJK
121 */
122 HWTEST_F(IpcServerStubTest, OnStop_001, testing::ext::TestSize.Level0)
123 {
124 // 1. Call IpcServerStub OnStop
125 IpcServerStub::GetInstance().OnStop();
126 // 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
127 ASSERT_EQ(ServiceRunningState::STATE_NOT_START, IpcServerStub::GetInstance().state_);
128 ASSERT_EQ(IpcServerStub::GetInstance().registerToService_, false);
129 }
130
131 /**
132 * @tc.name: OnRemoteRequest_001
133 * @tc.desc: 1. Set Code = 999
134 * 2. Call IpcServerStub OnRemoteRequest with param
135 * 3. check ret not DM_OK
136 * @tc.type: FUNC
137 * @tc.require: AR000GHSJK
138 */
139 HWTEST_F(IpcServerStubTest, OnRemoteRequest_001, testing::ext::TestSize.Level0)
140 {
141 // 1. Set Code = 999
142 uint32_t code = 999;
143 MessageParcel data;
144 MessageParcel reply;
145 MessageOption option;
146 int ret = 0;
147 // 2. Call IpcServerStub OnRemoteRequest with param
148 ret = IpcServerStub::GetInstance().OnRemoteRequest(code, data, reply, option);
149 // 3. check ret not DM_OK
150 ASSERT_NE(ret, DM_OK);
151 }
152
153 /**
154 * @tc.name: OnRemoteRequest_002
155 * @tc.desc: 1. Set Code = 999
156 * 2. Call IpcServerStub OnRemoteRequest with param
157 * 3. check ret not DM_OK
158 * @tc.type: FUNC
159 * @tc.require: AR000GHSJK
160 */
161 HWTEST_F(IpcServerStubTest, OnRemoteRequest_002, testing::ext::TestSize.Level0)
162 {
163 // 1. Set Code is SERVER_DEVICE_STATE_NOTIFY
164 uint32_t code = SERVER_DEVICE_STATE_NOTIFY;
165 MessageParcel data;
166 MessageParcel reply;
167 MessageOption option;
168 int ret = 0;
169 // 2. Call IpcServerStub OnRemoteRequest with param
170 ret = IpcServerStub::GetInstance().OnRemoteRequest(code, data, reply, option);
171 // 3. check ret not DM_OK
172 ASSERT_NE(ret, DM_OK);
173 }
174
175 /**
176 * @tc.name: SendCmd_001
177 * @tc.desc: 1. Call IpcServerStub SendCmd
178 * 2. check ret is DM_OK
179 * @tc.type: FUNC
180 * @tc.require: AR000GHSJK
181 */
182 HWTEST_F(IpcServerStubTest, SendCmd_001, testing::ext::TestSize.Level0)
183 {
184 int32_t cmdCode = 1;
185 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
186 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
187 // 1. Call IpcServerStub SendCmd
188 int32_t ret = IpcServerStub::GetInstance().SendCmd(cmdCode, req, rsp);
189 // 2. check ret is DM_OK
190 ASSERT_EQ(ret, DM_OK);
191 }
192
193 /**
194 * @tc.name: QueryServiceState_001
195 * @tc.desc: 1. Call IpcServerStub QueryServiceState
196 * 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
197 * @tc.type: FUNC
198 * @tc.require: AR000GHSJK
199 */
200 HWTEST_F(IpcServerStubTest, QueryServiceState_001, testing::ext::TestSize.Level0)
201 {
202 IpcServerStub::GetInstance().state_ = ServiceRunningState::STATE_NOT_START;
203 // 1. Call IpcServerStub QueryServiceState
204 ServiceRunningState state = IpcServerStub::GetInstance().QueryServiceState();
205 // 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
206 ASSERT_EQ(state, ServiceRunningState::STATE_NOT_START);
207 }
208
209 /**
210 * @tc.name: RegisterDeviceManagerListener_001
211 * @tc.desc: 1. Call IpcServerStub RegisterDeviceManagerListener
212 * 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
213 * @tc.type: FUNC
214 * @tc.require: AR000GHSJK
215 */
216 HWTEST_F(IpcServerStubTest, RegisterDeviceManagerListener_001, testing::ext::TestSize.Level0)
217 {
218 std::string pkgName = "";
219 int ret = 0;
220 sptr<IRemoteObject> listener = nullptr;
221 ret = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
222 ASSERT_EQ(ret, DM_POINT_NULL);
223 }
224
225 /**
226 * @tc.name: RegisterDeviceManagerListener_002
227 * @tc.desc: 1. Call IpcServerStub RegisterDeviceManagerListener
228 * 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
229 * @tc.type: FUNC
230 * @tc.require: AR000GHSJK
231 */
232 HWTEST_F(IpcServerStubTest, RegisterDeviceManagerListener_002, testing::ext::TestSize.Level0)
233 {
234 std::string pkgName = "com.ohos.test";
235 int ret = 0;
236 sptr<IRemoteObject> listener = sptr<IpcClientStub>(new IpcClientStub());
237 ret = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
238 ASSERT_EQ(ret, DM_OK);
239 }
240
241 /**
242 * @tc.name: RegisterDeviceManagerListener_003
243 * @tc.desc: 1. Call IpcServerStub RegisterDeviceManagerListener
244 * 2. check IpcServerStub.state is ServiceRunningState::STATE_RUNNING
245 * @tc.type: FUNC
246 * @tc.require: AR000GHSJK
247 */
248 HWTEST_F(IpcServerStubTest, RegisterDeviceManagerListener_003, testing::ext::TestSize.Level0)
249 {
250 std::string pkgName = "";
251 int ret = 0;
252 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
253 ret = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
254 ASSERT_EQ(ret, DM_POINT_NULL);
255 }
256
257 /**
258 * @tc.name: RegisterDeviceManagerListener_004
259 * @tc.desc: 1. Set PkgName is com.ohos.test
260 * 2. Call IpcServerStub RegisterDeviceManagerListener with param
261 * 3. check ret is DM_OK
262 * @tc.type: FUNC
263 * @tc.require: AR000GHSJK
264 */
265 HWTEST_F(IpcServerStubTest, RegisterDeviceManagerListener_004, testing::ext::TestSize.Level0)
266 {
267 // 1. Set PkgName is com.ohos.test
268 std::string pkgName = "com.ohos.test";
269 int ret = 0;
270 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
271 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
272 ret = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
273 // 3. check ret is DM_OK
274 ASSERT_EQ(ret, DM_OK);
275 }
276
277 /**
278 * @tc.name: RegisterDeviceManagerListener_005
279 * @tc.desc: 1. Set PkgName is com.ohos.test
280 * 2. Call IpcServerStub RegisterDeviceManagerListener with param
281 * 3. check ret is DM_OK
282 * 4. Call IpcServerStub RegisterDeviceManagerListener with same pkgName another listener
283 * 5. check result is DM_OK
284 * @tc.type: FUNC
285 * @tc.require: AR000GHSJK
286 */
287 HWTEST_F(IpcServerStubTest, RegisterDeviceManagerListener_005, testing::ext::TestSize.Level0)
288 {
289 // 1. Set PkgName is com.ohos.test
290 std::string pkgName = "com.ohos.test";
291 int ret = 0;
292 int result = 0;
293 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
294 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
295 ret = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
296 // 3. check ret is DM_OK
297 ASSERT_EQ(ret, DM_OK);
298 sptr<IpcClientStub> listener2 = sptr<IpcClientStub>(new IpcClientStub());
299 // 4. Call IpcServerStub RegisterDeviceManagerListener with same pkgName another listener
300 result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener2);
301 // 5. check result is DM_OK
302 ASSERT_EQ(result, DM_OK);
303 }
304
305 /**
306 * @tc.name: UnRegisterDeviceManagerListener_001
307 * @tc.desc: 1. Call IpcServerStub UnRegisterDeviceManagerListener
308 * 2. check ret is DM_POINT_NULL
309 * @tc.type: FUNC
310 * @tc.require: AR000GHSJK
311 */
312 HWTEST_F(IpcServerStubTest, UnRegisterDeviceManagerListener_001, testing::ext::TestSize.Level0)
313 {
314 std::string pkgName = "";
315 int ret = 0;
316 ret = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName);
317 ASSERT_EQ(ret, DM_POINT_NULL);
318 }
319
320 /**
321 * @tc.name: UnRegisterDeviceManagerListener_002
322 * @tc.desc: 1. Set PkgName is com.ohos.test
323 * 2. Call IpcServerStub RegisterDeviceManagerListener with param
324 * 3. check ret is DM_OK
325 * 4. Call IpcServerStub UnRegisterDeviceManagerListener
326 * 5. check ret is DM_OK
327 * @tc.type: FUNC
328 * @tc.require: AR000GHSJK
329 */
330 HWTEST_F(IpcServerStubTest, UnRegisterDeviceManagerListener_002, testing::ext::TestSize.Level0)
331 {
332 // 1. Set PkgName is com.ohos.test
333 std::string pkgName = "com.ohos.test";
334 int ret = 0;
335 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
336 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
337 ret = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
338 // 3. check ret is DM_OK
339 ASSERT_EQ(ret, DM_OK);
340 int result = 0;
341 // 4. Call IpcServerStub UnRegisterDeviceManagerListener
342 result = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName);
343 // 5. check ret is DM_OK
344 ASSERT_EQ(result, DM_OK);
345 }
346
347 /**
348 * @tc.name: UnRegisterDeviceManagerListener_003
349 * @tc.desc: 1. Set pkgName is com.ohos.test
350 * 2. Call IpcServerStub UnRegisterDeviceManagerListener
351 * 3. check ret is DM_OK
352 * @tc.type: FUNC
353 * @tc.require: AR000GHSJK
354 */
355 HWTEST_F(IpcServerStubTest, UnRegisterDeviceManagerListener_003, testing::ext::TestSize.Level0)
356 {
357 // 1. Set pkgName is com.ohos.test
358 std::string pkgName = "com.ohos.test";
359 int ret = 0;
360 // 2. Call IpcServerStub UnRegisterDeviceManagerListener
361 ret = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName);
362 // 3. check ret is DM_OK
363 ASSERT_EQ(ret, DM_OK);
364 }
365
366 /**
367 * @tc.name: UnRegisterDeviceManagerListener_004
368 * @tc.desc: 1. Set PkgName is com.ohos.test
369 * 2. Call IpcServerStub RegisterDeviceManagerListener with param
370 * 3. check ret is DM_OK
371 * 4. Call IpcServerStub UnRegisterDeviceManagerListener
372 * 5. check ret is DM_OK
373 * @tc.type: FUNC
374 * @tc.require: AR000GHSJK
375 */
376 HWTEST_F(IpcServerStubTest, UnRegisterDeviceManagerListener_004, testing::ext::TestSize.Level0)
377 {
378 // 1. Set PkgName is com.ohos.test
379 std::string pkgName = "com.ohos.test1";
380 int ret = 0;
381 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
382 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
383 ret = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
384 // 3. check ret is DM_OK
385 ASSERT_EQ(ret, DM_OK);
386 int result = 0;
387 // 4. Call IpcServerStub UnRegisterDeviceManagerListener
388 result = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName);
389 // 5. check ret is DM_OK
390 ASSERT_EQ(result, DM_OK);
391 sptr<IRemoteObject> dmListener = IpcServerStub::GetInstance().dmListener_[pkgName];
392 ASSERT_EQ(dmListener, nullptr);
393 }
394
395 /**
396 * @tc.name: UnRegisterDeviceManagerListener_005
397 * @tc.desc: 1. Set PkgName is com.ohos.test
398 * 2. Call IpcServerStub RegisterDeviceManagerListener with param
399 * 3. check ret is DM_OK
400 * 4. Call IpcServerStub UnRegisterDeviceManagerListener
401 * 5. check ret is DM_OK
402 * @tc.type: FUNC
403 * @tc.require: AR000GHSJK
404 */
405 HWTEST_F(IpcServerStubTest, UnRegisterDeviceManagerListener_005, testing::ext::TestSize.Level0)
406 {
407 // 1. Set PkgName is com.ohos.test
408 std::string pkgName = "com.ohos.test2";
409 int ret = 0;
410 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
411 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
412 ret = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
413 // 3. check ret is DM_OK
414 ASSERT_EQ(ret, DM_OK);
415 int result = 0;
416 // 4. Call IpcServerStub UnRegisterDeviceManagerListener
417 std::string testPkgName = "com.test";
418 result = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(testPkgName);
419 // 5. check ret is DM_OK
420 ASSERT_EQ(result, DM_OK);
421 sptr<IRemoteObject> dmListener = IpcServerStub::GetInstance().dmListener_[pkgName];
422 ASSERT_NE(dmListener, nullptr);
423 }
424
425 /**
426 * @tc.name: GetDmListener_001
427 * @tc.desc: 1. Set pkgName is com.ohos.test
428 * 2. Call IpcServerStub GetDmListener
429 * 3. check ret is DM_OK
430 * @tc.type: FUNC
431 * @tc.require: AR000GHSJK
432 */
433 HWTEST_F(IpcServerStubTest, GetDmListener_001, testing::ext::TestSize.Level0)
434 {
435 // 1. Set pkgName is com.ohos.test
436 std::string pkgName = "com.ohos.test";
437 sptr<IpcRemoteBroker> ret = nullptr;
438 // 2. Call IpcServerStub UnRegisterDeviceManagerListener
439 ret = IpcServerStub::GetInstance().GetDmListener(pkgName);
440 // 3. check ret is DM_OK
441 ASSERT_EQ(ret, nullptr);
442 }
443
444 /**
445 * @tc.name: GetDmListener_002
446 * @tc.desc: 1. Set pkgName is com.ohos.test
447 * 2. Call IpcServerStub GetDmListener
448 * 3. check ret is DM_OK
449 * @tc.type: FUNC
450 * @tc.require: AR000GHSJK
451 */
452 HWTEST_F(IpcServerStubTest, GetDmListener_002, testing::ext::TestSize.Level0)
453 {
454 // 1. Set pkgName is com.ohos.test
455 std::string pkgName = "com.ohos.test";
456 int result = 0;
457 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
458 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
459 result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
460 // 3. check ret is DM_OK
461 ASSERT_EQ(result, DM_OK);
462 sptr<IpcRemoteBroker> ret = nullptr;
463 // 2. Call IpcServerStub UnRegisterDeviceManagerListener
464 ret = IpcServerStub::GetInstance().GetDmListener(pkgName);
465 // 3. check ret is DM_OK
466 ASSERT_NE(ret, nullptr);
467 }
468
469 /**
470 * @tc.name: GetDmListener_003
471 * @tc.desc: 1. Set pkgName is com.ohos.test
472 * 2. Call IpcServerStub GetDmListener
473 * 3. check ret is DM_OK
474 * @tc.type: FUNC
475 * @tc.require: AR000GHSJK
476 */
477 HWTEST_F(IpcServerStubTest, GetDmListener_003, testing::ext::TestSize.Level0)
478 {
479 // 1. Set pkgName is com.ohos.test
480 std::string pkgName = "com.ohos.test";
481 int result = 0;
482 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
483 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
484 result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
485 // 3. check ret is DM_OK
486 ASSERT_EQ(result, DM_OK);
487 sptr<IpcRemoteBroker> ret = nullptr;
488 // 2. Call IpcServerStub UnRegisterDeviceManagerListener
489 std::string testPkgName = "test";
490 ret = IpcServerStub::GetInstance().GetDmListener(testPkgName);
491 // 3. check ret is DM_OK
492 ASSERT_EQ(ret, nullptr);
493 }
494
495 /**
496 * @tc.name: GetDmListener_004
497 * @tc.desc: 1. Set pkgName is com.ohos.test
498 * 2. Call IpcServerStub GetDmListener
499 * 3. check ret is DM_POINT_NULL
500 * @tc.type: FUNC
501 * @tc.require: AR000GHSJK
502 */
503 HWTEST_F(IpcServerStubTest, GetDmListener_004, testing::ext::TestSize.Level0)
504 {
505 // 1. Set pkgName is null
506 std::string pkgName = "";
507 int result = 0;
508 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
509 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
510 result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
511 // 3. check ret is DM_POINT_NULL
512 ASSERT_EQ(result, DM_POINT_NULL);
513 sptr<IpcRemoteBroker> ret = nullptr;
514 // 2. Call IpcServerStub UnRegisterDeviceManagerListener
515 ret = IpcServerStub::GetInstance().GetDmListener(pkgName);
516 // 3. check ret is nullptr
517 ASSERT_EQ(ret, nullptr);
518 }
519
520 /**
521 * @tc.name: GetDmListener_005
522 * @tc.desc: 1. Set pkgName is com.ohos.test
523 * 2. Call IpcServerStub GetDmListener
524 * 3. check ret is DM_POINT_NULL
525 * @tc.type: FUNC
526 * @tc.require: AR000GHSJK
527 */
528 HWTEST_F(IpcServerStubTest, GetDmListener_005, testing::ext::TestSize.Level0)
529 {
530 // 1. Set pkgName is null
531 std::string pkgName = "com.test.ohos";
532 int result = 0;
533 sptr<IpcClientStub> listener = nullptr;
534 // 2. Call IpcServerStub RegisterDeviceManagerListener with param
535 result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
536 // 3. check ret is DM_POINT_NULL
537 ASSERT_EQ(result, DM_POINT_NULL);
538 sptr<IpcRemoteBroker> ret = nullptr;
539 // 2. Call IpcServerStub UnRegisterDeviceManagerListener
540 ret = IpcServerStub::GetInstance().GetDmListener(pkgName);
541 // 3. check ret is nullptr
542 ASSERT_EQ(ret, nullptr);
543 }
544 } // namespace
545 } // namespace DistributedHardware
546 } // namespace OHOS
547