1 /*
2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include <unistd.h>
10 #include <cstdint>
11 #include <cstdio>
12 #include <cstdlib>
13 #include <fcntl.h>
14 #include <cinttypes>
15 #include <string>
16 #include <gtest/gtest.h>
17 #include "hdf_io_service.h"
18 #include "hdf_log.h"
19 #include "hdf_power_state.h"
20 #include "hdf_sbuf.h"
21 #include "hdf_uhdf_test.h"
22 #include "ioservstat_listener.h"
23 #include "osal_time.h"
24 #include "sample_driver_test.h"
25 #include "svcmgr_ioservice.h"
26
27 using namespace testing::ext;
28
29 struct Eventlistener {
30 struct HdfDevEventlistener listener;
31 int32_t eventCount;
32 };
33
34 class IoServiceTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp();
39 void TearDown();
40 static int OnDevEventReceived(
41 struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t id, struct HdfSBuf *data);
42
43 void TestServiceStop(struct IoServiceStatusData* issd);
44 static struct Eventlistener listener0;
45 static struct Eventlistener listener1;
46 const char *testSvcName = SAMPLE_SERVICE;
47 const int eventWaitTimeUs = (150 * 1000);
48 static int eventCount;
49 const int servstatWaitTime = 15; // ms
50 };
51
52 int IoServiceTest::eventCount = 0;
53
54 struct Eventlistener IoServiceTest::listener0;
55 struct Eventlistener IoServiceTest::listener1;
56
SetUpTestCase()57 void IoServiceTest::SetUpTestCase()
58 {
59 listener0.listener.onReceive = OnDevEventReceived;
60 listener0.listener.priv = const_cast<void *>(static_cast<const void *>("listener0"));
61
62 listener1.listener.onReceive = OnDevEventReceived;
63 listener1.listener.priv = const_cast<void *>(static_cast<const void *>("listener1"));
64 }
65
TearDownTestCase()66 void IoServiceTest::TearDownTestCase()
67 {
68 }
69
SetUp()70 void IoServiceTest::SetUp()
71 {
72 listener0.eventCount = 0;
73 listener1.eventCount = 0;
74 eventCount = 0;
75 }
76
TearDown()77 void IoServiceTest::TearDown()
78 {
79 }
80
OnDevEventReceived(struct HdfDevEventlistener * listener,struct HdfIoService * service,uint32_t id,struct HdfSBuf * data)81 int IoServiceTest::OnDevEventReceived(
82 struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t id, struct HdfSBuf *data)
83 {
84 OsalTimespec time;
85 OsalGetTime(&time);
86 HDF_LOGE("%s: received event[%d] from %s at %" PRIu64 ".%" PRIu64 "", static_cast<char *>(listener->priv),
87 eventCount++, static_cast<char *>(service->priv), time.sec, time.usec);
88
89 const char *string = HdfSbufReadString(data);
90 if (string == nullptr) {
91 HDF_LOGE("failed to read string in event data");
92 return 0;
93 }
94 struct Eventlistener *l = CONTAINER_OF(listener, struct Eventlistener, listener);
95 l->eventCount++;
96 HDF_LOGE("%s: dev event received: %u %s", static_cast<char *>(service->priv), id, string);
97 return 0;
98 }
99
SendEvent(struct HdfIoService * serv,const char * eventData,bool broadcast)100 static int SendEvent(struct HdfIoService *serv, const char *eventData, bool broadcast)
101 {
102 OsalTimespec time;
103 OsalGetTime(&time);
104
105 int ret;
106 struct HdfSBuf *data = HdfSbufObtainDefaultSize();
107 if (data == nullptr) {
108 HDF_LOGE("fail to obtain sbuf data");
109 return HDF_FAILURE;
110 }
111
112 struct HdfSBuf *reply = HdfSbufObtainDefaultSize();
113 if (reply == nullptr) {
114 HDF_LOGE("fail to obtain sbuf reply");
115 HdfSbufRecycle(data);
116 return HDF_DEV_ERR_NO_MEMORY;
117 }
118
119 uint32_t cmdId = broadcast ? SAMPLE_DRIVER_SENDEVENT_BROADCAST_DEVICE : SAMPLE_DRIVER_SENDEVENT_SINGLE_DEVICE;
120 do {
121 if (!HdfSbufWriteString(data, eventData)) {
122 HDF_LOGE("fail to write sbuf");
123 ret = HDF_FAILURE;
124 break;
125 }
126
127 ret = serv->dispatcher->Dispatch(&serv->object, cmdId, data, reply);
128 if (ret != HDF_SUCCESS) {
129 HDF_LOGE("fail to send service call");
130 break;
131 }
132
133 int replyData = 0;
134 if (!HdfSbufReadInt32(reply, &replyData)) {
135 HDF_LOGE("fail to get service call reply");
136 ret = HDF_ERR_INVALID_OBJECT;
137 } else if (replyData != INT32_MAX) {
138 HDF_LOGE("service call reply check fail, replyData=0x%x", replyData);
139 ret = HDF_ERR_INVALID_OBJECT;
140 }
141 HDF_LOGE("send event finish at %" PRIu64 ".%" PRIu64 "", time.sec, time.usec);
142 } while (0);
143
144 HdfSbufRecycle(data);
145 HdfSbufRecycle(reply);
146 return ret;
147 }
148
149 /* *
150 * @tc.name: HdfIoService001
151 * @tc.desc: service bind test
152 * @tc.type: FUNC
153 * @tc.require: AR000F869B
154 */
155 HWTEST_F(IoServiceTest, HdfIoService001, TestSize.Level0)
156 {
157 struct HdfIoService *testServ = HdfIoServiceBind(testSvcName);
158 ASSERT_NE(testServ, nullptr);
159 HdfIoServiceRecycle(testServ);
160 }
161
162 /* *
163 * @tc.name: HdfIoService002
164 * @tc.desc: service group listen test
165 * @tc.type: FUNC
166 * @tc.require: AR000F869B
167 */
168 HWTEST_F(IoServiceTest, HdfIoService002, TestSize.Level0)
169 {
170 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
171 ASSERT_NE(serv, nullptr);
172 serv->priv = const_cast<void *>(static_cast<const void *>("serv0"));
173
174 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
175 ASSERT_NE(group, nullptr);
176
177 int ret = HdfIoServiceGroupAddService(group, serv);
178 ASSERT_EQ(ret, HDF_SUCCESS);
179
180 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
181 ASSERT_EQ(ret, HDF_SUCCESS);
182
183 ret = SendEvent(serv, testSvcName, false);
184 ASSERT_EQ(ret, HDF_SUCCESS);
185
186 usleep(eventWaitTimeUs);
187 ASSERT_EQ(1, listener0.eventCount);
188
189 ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener);
190 ASSERT_EQ(ret, HDF_SUCCESS);
191
192 HdfIoServiceGroupRecycle(group);
193 group = HdfIoServiceGroupObtain();
194 ASSERT_NE(group, nullptr);
195
196 ret = HdfIoServiceGroupAddService(group, serv);
197 ASSERT_EQ(ret, HDF_SUCCESS);
198
199 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
200 ASSERT_EQ(ret, HDF_SUCCESS);
201
202 ret = SendEvent(serv, testSvcName, false);
203 ASSERT_EQ(ret, HDF_SUCCESS);
204
205 usleep(eventWaitTimeUs);
206 ASSERT_EQ(2, listener0.eventCount);
207 HdfIoServiceGroupRecycle(group);
208
209 HdfIoServiceRecycle(serv);
210 }
211
212 /* *
213 * @tc.name: HdfIoService003
214 * @tc.desc: remove service from service group by recycle group test
215 * @tc.type: FUNC
216 * @tc.require: AR000F869B
217 */
218 HWTEST_F(IoServiceTest, HdfIoService003, TestSize.Level0)
219 {
220 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
221 ASSERT_NE(serv, nullptr);
222 serv->priv = const_cast<void *>(static_cast<const void *>("serv0"));
223
224 struct HdfIoService *serv1 = HdfIoServiceBind(testSvcName);
225 ASSERT_NE(serv1, nullptr);
226 serv1->priv = const_cast<void *>(static_cast<const void *>("serv1"));
227
228 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
229 ASSERT_NE(group, nullptr);
230
231 int ret = HdfIoServiceGroupAddService(group, serv);
232 ASSERT_EQ(ret, HDF_SUCCESS);
233
234 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
235 ASSERT_EQ(ret, HDF_SUCCESS);
236
237 ret = SendEvent(serv, testSvcName, false);
238 ASSERT_EQ(ret, HDF_SUCCESS);
239
240 usleep(eventWaitTimeUs);
241 ASSERT_EQ(1, listener0.eventCount);
242
243 ret = HdfIoServiceGroupAddService(group, serv1);
244 ASSERT_EQ(ret, HDF_SUCCESS);
245
246 ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener);
247 ASSERT_EQ(ret, HDF_SUCCESS);
248
249 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
250 ASSERT_EQ(ret, HDF_SUCCESS);
251
252 ret = HdfDeviceRegisterEventListener(serv, &listener1.listener);
253 ASSERT_EQ(ret, HDF_SUCCESS);
254
255 ret = SendEvent(serv, testSvcName, false);
256 ASSERT_EQ(ret, HDF_SUCCESS);
257
258 usleep(eventWaitTimeUs);
259 ASSERT_EQ(2, listener0.eventCount);
260 ASSERT_EQ(1, listener1.eventCount);
261 HdfIoServiceGroupRecycle(group);
262 HdfDeviceUnregisterEventListener(serv, &listener1.listener);
263 HdfIoServiceRecycle(serv);
264 HdfIoServiceRecycle(serv1);
265 }
266
267 /* *
268 * @tc.name: HdfIoService004
269 * @tc.desc: single service listen test
270 * @tc.type: FUNC
271 * @tc.require: AR000F869B
272 */
273 HWTEST_F(IoServiceTest, HdfIoService004, TestSize.Level0)
274 {
275 struct HdfIoService *serv1 = HdfIoServiceBind(testSvcName);
276 ASSERT_NE(serv1, nullptr);
277 serv1->priv = const_cast<void *>(static_cast<const void *>("serv1"));
278
279 int ret = HdfDeviceRegisterEventListener(serv1, &listener0.listener);
280 ASSERT_EQ(ret, HDF_SUCCESS);
281 ret = SendEvent(serv1, testSvcName, false);
282 ASSERT_EQ(ret, HDF_SUCCESS);
283
284 usleep(eventWaitTimeUs);
285 ASSERT_EQ(1, listener0.eventCount);
286
287 ret = HdfDeviceUnregisterEventListener(serv1, &listener0.listener);
288 ASSERT_EQ(ret, HDF_SUCCESS);
289 HdfIoServiceRecycle(serv1);
290 }
291
292 /* *
293 * @tc.name: HdfIoService005
294 * @tc.desc: service group add remove test
295 * @tc.type: FUNC
296 * @tc.require: AR000F869B
297 */
298 HWTEST_F(IoServiceTest, HdfIoService005, TestSize.Level0)
299 {
300 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
301 ASSERT_NE(serv, nullptr);
302 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
303
304 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
305 ASSERT_NE(group, nullptr);
306
307 int ret = HdfIoServiceGroupAddService(group, serv);
308 ASSERT_EQ(ret, HDF_SUCCESS);
309
310 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
311 ASSERT_EQ(ret, HDF_SUCCESS);
312
313 ret = SendEvent(serv, testSvcName, false);
314 ASSERT_EQ(ret, HDF_SUCCESS);
315
316 usleep(eventWaitTimeUs);
317 ASSERT_EQ(1, listener0.eventCount);
318
319 HdfIoServiceGroupRemoveService(group, serv);
320
321 ret = HdfIoServiceGroupAddService(group, serv);
322 ASSERT_EQ(ret, HDF_SUCCESS);
323
324 ret = SendEvent(serv, testSvcName, false);
325 ASSERT_EQ(ret, HDF_SUCCESS);
326
327 usleep(eventWaitTimeUs);
328 ASSERT_EQ(2, listener0.eventCount);
329 HdfIoServiceGroupRecycle(group);
330 }
331
332 /* *
333 * @tc.name: HdfIoService006
334 * @tc.desc: service group add remove listener test
335 * @tc.type: FUNC
336 * @tc.require: AR000F869B
337 */
338 HWTEST_F(IoServiceTest, HdfIoService006, TestSize.Level0)
339 {
340 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
341 ASSERT_NE(group, nullptr);
342
343 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
344 ASSERT_NE(serv, nullptr);
345 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
346
347 struct HdfIoService *serv1 = HdfIoServiceBind(testSvcName);
348 ASSERT_NE(serv1, nullptr);
349 serv1->priv = const_cast<void *>(static_cast<const void *>("serv1"));
350
351 int ret = HdfIoServiceGroupAddService(group, serv);
352 ASSERT_EQ(ret, HDF_SUCCESS);
353
354 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
355 ASSERT_EQ(ret, HDF_SUCCESS);
356
357 ret = HdfIoServiceGroupAddService(group, serv1);
358 ASSERT_EQ(ret, HDF_SUCCESS);
359
360 ret = SendEvent(serv, testSvcName, false);
361 ASSERT_EQ(ret, HDF_SUCCESS);
362
363 usleep(eventWaitTimeUs);
364 ASSERT_EQ(1, listener0.eventCount);
365
366 ret = SendEvent(serv1, testSvcName, false);
367 ASSERT_EQ(ret, HDF_SUCCESS);
368
369 usleep(eventWaitTimeUs);
370 ASSERT_EQ(2, listener0.eventCount);
371
372 HdfIoServiceGroupRemoveService(group, serv);
373
374 ret = SendEvent(serv, testSvcName, false);
375 ASSERT_EQ(ret, HDF_SUCCESS);
376
377 usleep(eventWaitTimeUs);
378 ASSERT_EQ(2, listener0.eventCount);
379
380 ret = SendEvent(serv1, testSvcName, false);
381 ASSERT_EQ(ret, HDF_SUCCESS);
382
383 usleep(eventWaitTimeUs);
384 ASSERT_EQ(3, listener0.eventCount);
385
386 ret = HdfIoServiceGroupAddService(group, serv);
387 ASSERT_EQ(ret, HDF_SUCCESS);
388
389 ret = SendEvent(serv, testSvcName, false);
390 ASSERT_EQ(ret, HDF_SUCCESS);
391
392 usleep(eventWaitTimeUs);
393 ASSERT_EQ(4, listener0.eventCount);
394
395 HdfIoServiceGroupRecycle(group);
396 HdfIoServiceRecycle(serv);
397 HdfIoServiceRecycle(serv1);
398 }
399
400 /* *
401 * @tc.name: HdfIoService007
402 * @tc.desc: duplicate remove group listener
403 * @tc.type: FUNC
404 * @tc.require: AR000F869B
405 */
406 HWTEST_F(IoServiceTest, HdfIoService007, TestSize.Level0)
407 {
408 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
409 ASSERT_NE(group, nullptr);
410
411 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
412 ASSERT_NE(serv, nullptr);
413 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
414
415 int ret = HdfIoServiceGroupAddService(group, serv);
416 ASSERT_EQ(ret, HDF_SUCCESS);
417
418 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
419 ASSERT_EQ(ret, HDF_SUCCESS);
420
421 ret = SendEvent(serv, testSvcName, false);
422 ASSERT_EQ(ret, HDF_SUCCESS);
423
424 usleep(eventWaitTimeUs);
425 ASSERT_EQ(1, listener0.eventCount);
426
427 ret = HdfIoServiceGroupUnregisterListener(group, &listener0.listener);
428 EXPECT_EQ(ret, HDF_SUCCESS);
429
430 ret = HdfIoServiceGroupUnregisterListener(group, &listener0.listener);
431 EXPECT_NE(ret, HDF_SUCCESS);
432
433 HdfIoServiceGroupRecycle(group);
434 HdfIoServiceRecycle(serv);
435 }
436
437 /* *
438 * @tc.name: HdfIoService008
439 * @tc.desc: duplicate add group listener
440 * @tc.type: FUNC
441 * @tc.require: AR000F869B
442 */
443 HWTEST_F(IoServiceTest, HdfIoService008, TestSize.Level0)
444 {
445 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
446 ASSERT_NE(group, nullptr);
447
448 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
449 ASSERT_NE(serv, nullptr);
450 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
451
452 int ret = HdfIoServiceGroupAddService(group, serv);
453 ASSERT_EQ(ret, HDF_SUCCESS);
454
455 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
456 ASSERT_EQ(ret, HDF_SUCCESS);
457
458 ret = SendEvent(serv, testSvcName, false);
459 ASSERT_EQ(ret, HDF_SUCCESS);
460
461 usleep(eventWaitTimeUs);
462 ASSERT_EQ(1, listener0.eventCount);
463
464 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
465 EXPECT_NE(ret, HDF_SUCCESS);
466
467 ret = HdfIoServiceGroupUnregisterListener(group, &listener0.listener);
468 ASSERT_EQ(ret, HDF_SUCCESS);
469
470 HdfIoServiceGroupRecycle(group);
471 HdfIoServiceRecycle(serv);
472 }
473
474 /* *
475 * @tc.name: HdfIoService008
476 * @tc.desc: duplicate add service
477 * @tc.type: FUNC
478 * @tc.require: AR000F869B
479 */
480 HWTEST_F(IoServiceTest, HdfIoService009, TestSize.Level0)
481 {
482 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
483 ASSERT_NE(group, nullptr);
484
485 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
486 ASSERT_NE(serv, nullptr);
487 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
488
489 int ret = HdfIoServiceGroupAddService(group, serv);
490 ASSERT_EQ(ret, HDF_SUCCESS);
491
492 ret = HdfIoServiceGroupAddService(group, serv);
493 EXPECT_NE(ret, HDF_SUCCESS);
494
495 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
496 ASSERT_EQ(ret, HDF_SUCCESS);
497
498 ret = SendEvent(serv, testSvcName, false);
499 ASSERT_EQ(ret, HDF_SUCCESS);
500
501 usleep(eventWaitTimeUs);
502 ASSERT_EQ(1, listener0.eventCount);
503
504 ret = HdfIoServiceGroupUnregisterListener(group, &listener0.listener);
505 ASSERT_EQ(ret, HDF_SUCCESS);
506
507 HdfIoServiceGroupRecycle(group);
508 HdfIoServiceRecycle(serv);
509 }
510
511 /* *
512 * @tc.name: HdfIoService010
513 * @tc.desc: duplicate remove service
514 * @tc.type: FUNC
515 * @tc.require: AR000F869B
516 */
517 HWTEST_F(IoServiceTest, HdfIoService010, TestSize.Level0)
518 {
519 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
520 ASSERT_NE(group, nullptr);
521
522 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
523 ASSERT_NE(serv, nullptr);
524 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
525
526 int ret = HdfIoServiceGroupAddService(group, serv);
527 ASSERT_EQ(ret, HDF_SUCCESS);
528
529 ret = HdfIoServiceGroupAddService(group, serv);
530 EXPECT_NE(ret, HDF_SUCCESS);
531
532 ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener);
533 ASSERT_EQ(ret, HDF_SUCCESS);
534
535 ret = SendEvent(serv, testSvcName, false);
536 ASSERT_EQ(ret, HDF_SUCCESS);
537
538 usleep(eventWaitTimeUs);
539 ASSERT_EQ(1, listener0.eventCount);
540
541 HdfIoServiceGroupRemoveService(group, serv);
542 HdfIoServiceGroupRemoveService(group, serv);
543
544 ret = HdfIoServiceGroupUnregisterListener(group, &listener0.listener);
545 ASSERT_EQ(ret, HDF_SUCCESS);
546
547 HdfIoServiceGroupRecycle(group);
548 HdfIoServiceRecycle(serv);
549 }
550
551 /* *
552 * @tc.name: HdfIoService011
553 * @tc.desc: duplicate add service listener
554 * @tc.type: FUNC
555 * @tc.require: AR000F869B
556 */
557 HWTEST_F(IoServiceTest, HdfIoService011, TestSize.Level0)
558 {
559 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
560 ASSERT_NE(serv, nullptr);
561 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
562
563 int ret = HdfDeviceRegisterEventListener(serv, &listener0.listener);
564 ASSERT_EQ(ret, HDF_SUCCESS);
565
566 ret = SendEvent(serv, testSvcName, false);
567 ASSERT_EQ(ret, HDF_SUCCESS);
568
569 usleep(eventWaitTimeUs);
570 ASSERT_EQ(1, listener0.eventCount);
571
572 ret = HdfDeviceRegisterEventListener(serv, &listener0.listener);
573 EXPECT_NE(ret, HDF_SUCCESS);
574
575 ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener);
576 ASSERT_EQ(ret, HDF_SUCCESS);
577 HdfIoServiceRecycle(serv);
578 }
579
580 /* *
581 * @tc.name: HdfIoService012
582 * @tc.desc: duplicate remove service listener
583 * @tc.type: FUNC
584 * @tc.require: AR000F869B
585 */
586 HWTEST_F(IoServiceTest, HdfIoService012, TestSize.Level0)
587 {
588 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
589 ASSERT_NE(serv, nullptr);
590 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
591
592 int ret = HdfDeviceRegisterEventListener(serv, &listener0.listener);
593 ASSERT_EQ(ret, HDF_SUCCESS);
594
595 ret = SendEvent(serv, testSvcName, false);
596 ASSERT_EQ(ret, HDF_SUCCESS);
597
598 usleep(eventWaitTimeUs);
599 ASSERT_EQ(1, listener0.eventCount);
600
601 ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener);
602 ASSERT_EQ(ret, HDF_SUCCESS);
603
604 ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener);
605 EXPECT_NE(ret, HDF_SUCCESS);
606
607 HdfIoServiceRecycle(serv);
608 }
609
610 /* *
611 * @tc.name: HdfIoService013
612 * @tc.desc: devmgr power state change test
613 * @tc.type: FUNC
614 */
615 HWTEST_F(IoServiceTest, HdfIoService013, TestSize.Level0)
616 {
617 struct HdfSBuf *data = HdfSbufObtainDefaultSize();
618 ASSERT_NE(data, nullptr);
619
620 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
621 ASSERT_NE(serv, nullptr);
622
623 HdfSbufWriteUint32(data, POWER_STATE_SUSPEND);
624 int ret = serv->dispatcher->Dispatch(&serv->object, SAMPLE_DRIVER_PM_STATE_INJECT, data, nullptr);
625 ASSERT_EQ(ret, HDF_SUCCESS);
626
627 HdfSbufFlush(data);
628 HdfSbufWriteUint32(data, POWER_STATE_RESUME);
629 ret = serv->dispatcher->Dispatch(&serv->object, SAMPLE_DRIVER_PM_STATE_INJECT, data, nullptr);
630 ASSERT_EQ(ret, HDF_SUCCESS);
631
632 HdfSbufFlush(data);
633 HdfSbufWriteUint32(data, POWER_STATE_DOZE_SUSPEND);
634 ret = serv->dispatcher->Dispatch(&serv->object, SAMPLE_DRIVER_PM_STATE_INJECT, data, nullptr);
635 ASSERT_EQ(ret, HDF_SUCCESS);
636
637 HdfSbufFlush(data);
638 HdfSbufWriteUint32(data, POWER_STATE_DOZE_RESUME);
639 ret = serv->dispatcher->Dispatch(&serv->object, SAMPLE_DRIVER_PM_STATE_INJECT, data, nullptr);
640 ASSERT_EQ(ret, HDF_SUCCESS);
641 HdfIoServiceRecycle(serv);
642 HdfSbufRecycle(data);
643 }
644
645 /* *
646 * @tc.name: HdfIoService014
647 * @tc.desc: multiple clients listen to a service
648 * @tc.type: FUNC
649 * @tc.require:
650 */
651 HWTEST_F(IoServiceTest, HdfIoService014, TestSize.Level0)
652 {
653 struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain();
654 ASSERT_NE(group, nullptr);
655
656 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
657 ASSERT_NE(serv, nullptr);
658 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
659
660 struct HdfIoService *serv1 = HdfIoServiceBind(testSvcName);
661 ASSERT_NE(serv1, nullptr);
662 serv1->priv = const_cast<void *>(static_cast<const void *>("serv1"));
663
664 int ret = HdfDeviceRegisterEventListener(serv, &listener0.listener);
665 ASSERT_EQ(ret, HDF_SUCCESS);
666
667 ret = HdfDeviceRegisterEventListener(serv1, &listener1.listener);
668 ASSERT_EQ(ret, HDF_SUCCESS);
669
670 ret = SendEvent(serv, testSvcName, true);
671 ASSERT_EQ(ret, HDF_SUCCESS);
672
673 usleep(eventWaitTimeUs);
674 ASSERT_EQ(1, listener0.eventCount);
675 ASSERT_EQ(1, listener1.eventCount);
676
677 ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener);
678 ASSERT_EQ(ret, HDF_SUCCESS);
679
680 ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener);
681 EXPECT_NE(ret, HDF_SUCCESS);
682
683 ret = HdfDeviceUnregisterEventListener(serv1, &listener1.listener);
684 ASSERT_EQ(ret, HDF_SUCCESS);
685
686 HdfIoServiceRecycle(serv);
687 HdfIoServiceRecycle(serv1);
688 }
689
690 struct IoServiceStatusData {
IoServiceStatusDataIoServiceStatusData691 IoServiceStatusData(): devClass(0), servStatus(0), callbacked(false)
692 {
693 }
694 ~IoServiceStatusData() = default;
695 std::string servName;
696 std::string servInfo;
697 uint16_t devClass;
698 uint16_t servStatus;
699 bool callbacked;
700 };
701
TestOnServiceStatusReceived(struct ServiceStatusListener * listener,struct ServiceStatus * servstat)702 static void TestOnServiceStatusReceived(struct ServiceStatusListener *listener, struct ServiceStatus *servstat)
703 {
704 struct IoServiceStatusData *issd = static_cast<struct IoServiceStatusData *>(listener->priv);
705 if (issd == nullptr) {
706 return;
707 }
708 issd->servName = servstat->serviceName;
709 issd->servInfo = ((servstat->info != nullptr) ? (servstat->info) : (""));
710 issd->devClass = servstat->deviceClass;
711 issd->servStatus = servstat->status;
712 issd->callbacked = true;
713
714 HDF_LOGI("service status listener callback: %{public}s, %{public}s, %{public}d", servstat->serviceName,
715 issd->servName.data(), issd->servStatus);
716 }
717
718 /* *
719 * @tc.name: HdfIoService015
720 * @tc.desc: ioservice status listener test
721 * @tc.type: FUNC
722 * @tc.require
723 */
TestServiceStop(struct IoServiceStatusData * issd)724 void IoServiceTest::TestServiceStop(struct IoServiceStatusData* issd)
725 {
726 struct HdfIoService *testService = HdfIoServiceBind(SAMPLE_SERVICE);
727 ASSERT_TRUE(testService != nullptr);
728 struct HdfSBuf *data = HdfSbufObtainDefaultSize();
729 ASSERT_TRUE(data != nullptr);
730 const char *newServName = "sample_service1";
731 ASSERT_TRUE(HdfSbufWriteString(data, "sample_driver"));
732 ASSERT_TRUE(HdfSbufWriteString(data, newServName));
733
734 int ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_REGISTER_DEVICE, data, nullptr);
735 ASSERT_EQ(ret, HDF_SUCCESS);
736
737 int count = servstatWaitTime;
738 while (!issd->callbacked && count > 0) {
739 OsalMSleep(1);
740 count--;
741 }
742 ASSERT_TRUE(issd->callbacked);
743 ASSERT_EQ(issd->servName, newServName);
744 ASSERT_EQ(issd->devClass, DEVICE_CLASS_DEFAULT);
745 ASSERT_EQ(issd->servInfo, std::string(SAMPLE_SERVICE));
746 ASSERT_EQ(issd->servStatus, SERVIE_STATUS_START);
747
748 issd->callbacked = false;
749 ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_UNREGISTER_DEVICE, data, nullptr);
750 ASSERT_TRUE(ret == HDF_SUCCESS);
751
752 count = servstatWaitTime;
753 while (!issd->callbacked && count > 0) {
754 OsalMSleep(1);
755 count--;
756 }
757 ASSERT_TRUE(issd->callbacked);
758 ASSERT_EQ(issd->servName, newServName);
759 ASSERT_EQ(issd->devClass, DEVICE_CLASS_DEFAULT);
760 ASSERT_EQ(issd->servInfo, std::string(SAMPLE_SERVICE));
761 ASSERT_EQ(issd->servStatus, SERVIE_STATUS_STOP);
762
763 HdfIoServiceRecycle(testService);
764 HdfSbufRecycle(data);
765 }
766
767 HWTEST_F(IoServiceTest, HdfIoService015, TestSize.Level0)
768 {
769 struct ISvcMgrIoservice *servmgr = SvcMgrIoserviceGet();
770 ASSERT_NE(servmgr, nullptr);
771
772 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
773 ASSERT_NE(serv, nullptr);
774 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
775
776 struct IoServiceStatusData issd;
777 struct ServiceStatusListener *listener = IoServiceStatusListenerNewInstance();
778 listener->callback = TestOnServiceStatusReceived;
779 listener->priv = static_cast<void *>(&issd);
780
781 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
782 ASSERT_EQ(status, HDF_SUCCESS);
783
784 TestServiceStop(&issd);
785
786 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
787 ASSERT_EQ(status, HDF_SUCCESS);
788
789 IoServiceStatusListenerFree(listener);
790 SvcMgrIoserviceRelease(servmgr);
791 }
792
793 /* *
794 * @tc.name: HdfIoService016
795 * @tc.desc: ioservice status listener update info test
796 * @tc.type: FUNC
797 * @tc.require:
798 */
799 HWTEST_F(IoServiceTest, HdfIoService016, TestSize.Level0)
800 {
801 struct ISvcMgrIoservice *servmgr = SvcMgrIoserviceGet();
802 ASSERT_NE(servmgr, nullptr);
803
804 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
805 ASSERT_NE(serv, nullptr);
806 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
807
808 struct IoServiceStatusData issd;
809 struct ServiceStatusListener *listener = IoServiceStatusListenerNewInstance();
810 listener->callback = TestOnServiceStatusReceived;
811 listener->priv = static_cast<void *>(&issd);
812
813 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
814 ASSERT_EQ(status, HDF_SUCCESS);
815
816 struct HdfIoService *testService = HdfIoServiceBind(SAMPLE_SERVICE);
817 ASSERT_TRUE(testService != nullptr);
818 HdfSBuf *data = HdfSbufObtainDefaultSize();
819 ASSERT_TRUE(data != nullptr);
820
821 std::string servinfo = "foo";
822 ASSERT_TRUE(HdfSbufWriteString(data, servinfo.data()));
823 int ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_UPDATE_SERVICE_INFO, data, nullptr);
824 ASSERT_EQ(ret, HDF_SUCCESS);
825
826 int count = servstatWaitTime;
827 while (!issd.callbacked && count > 0) {
828 OsalMSleep(1);
829 count--;
830 }
831 ASSERT_TRUE(issd.callbacked);
832 ASSERT_EQ(issd.servName, SAMPLE_SERVICE);
833 ASSERT_EQ(issd.devClass, DEVICE_CLASS_DEFAULT);
834 ASSERT_EQ(issd.servInfo, servinfo);
835 ASSERT_EQ(issd.servStatus, SERVIE_STATUS_CHANGE);
836
837 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
838 ASSERT_EQ(status, HDF_SUCCESS);
839
840 IoServiceStatusListenerFree(listener);
841 HdfIoServiceRecycle(testService);
842 SvcMgrIoserviceRelease(servmgr);
843 HdfSbufRecycle(data);
844 }
845
846 /* *
847 * @tc.name: HdfIoService017
848 * @tc.desc: ioservice status listener unregister test
849 * @tc.type: FUNC
850 * @tc.require:
851 */
852 HWTEST_F(IoServiceTest, HdfIoService017, TestSize.Level0)
853 {
854 struct ISvcMgrIoservice *servmgr = SvcMgrIoserviceGet();
855 ASSERT_NE(servmgr, nullptr);
856
857 struct HdfIoService *serv = HdfIoServiceBind(testSvcName);
858 ASSERT_NE(serv, nullptr);
859 serv->priv = const_cast<void *>(static_cast<const void *>("serv"));
860
861 struct IoServiceStatusData issd;
862 struct ServiceStatusListener *listener = IoServiceStatusListenerNewInstance();
863 listener->callback = TestOnServiceStatusReceived;
864 listener->priv = static_cast<void *>(&issd);
865
866 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
867 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
868 ASSERT_EQ(status, HDF_SUCCESS);
869
870 struct HdfIoService *testService = HdfIoServiceBind(SAMPLE_SERVICE);
871 ASSERT_TRUE(testService != nullptr);
872 HdfSBuf *data = HdfSbufObtainDefaultSize();
873 ASSERT_TRUE(data != nullptr);
874 const char *newServName = "sample_service1";
875 ASSERT_TRUE(HdfSbufWriteString(data, "sample_driver"));
876 ASSERT_TRUE(HdfSbufWriteString(data, newServName));
877 int ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_REGISTER_DEVICE, data, nullptr);
878 ASSERT_EQ(ret, HDF_SUCCESS);
879
880 int count = 10;
881 while (!issd.callbacked && count > 0) {
882 OsalMSleep(1);
883 count--;
884 }
885 ASSERT_TRUE(issd.callbacked);
886 ASSERT_EQ(issd.servName, newServName);
887 ASSERT_EQ(issd.devClass, DEVICE_CLASS_DEFAULT);
888 ASSERT_EQ(issd.servInfo, std::string(SAMPLE_SERVICE));
889 ASSERT_EQ(issd.servStatus, SERVIE_STATUS_START);
890
891 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
892 ASSERT_EQ(status, HDF_SUCCESS);
893
894 issd.callbacked = false;
895 ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_UNREGISTER_DEVICE, data, nullptr);
896 ASSERT_EQ(status, HDF_SUCCESS);
897
898 OsalMSleep(10);
899
900 ASSERT_FALSE(issd.callbacked);
901 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
902 ASSERT_NE(status, HDF_SUCCESS);
903 IoServiceStatusListenerFree(listener);
904 HdfIoServiceRecycle(testService);
905 SvcMgrIoserviceRelease(servmgr);
906 HdfSbufRecycle(data);
907 }
908