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