1 /*
2 * Copyright (c) 2021-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 <devmgr_hdi.h>
17 #include <gtest/gtest.h>
18 #include <hdf_io_service_if.h>
19 #include <hdf_log.h>
20 #include <hdf_remote_service.h>
21 #include <hdf_sbuf.h>
22 #include <hdf_service_status.h>
23 #include <osal_time.h>
24 #include <servmgr_hdi.h>
25 #include <shared_mem.h>
26 #include <string>
27 #include <sys/mman.h>
28
29 #include "sample_hdi.h"
30
31 #define HDF_LOG_TAG service_manager_test
32
33 using namespace testing::ext;
34
35 static constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
36 static constexpr const char *TEST_SERVICE_INTERFACE_DESC = "hdf.test.sampele_service";
37 static constexpr int PAYLOAD_NUM = 1234;
38 static constexpr int WAIT_LOAD_UNLOAD_TIME = 300;
39 class HdfServiceMangerHdiCTest : public testing::Test {
40 public:
SetUpTestCase()41 static void SetUpTestCase()
42 {
43 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
44 if (devmgr != nullptr) {
45 devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
46 }
47 }
TearDownTestCase()48 static void TearDownTestCase()
49 {
50 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
51 if (devmgr != nullptr) {
52 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
53 }
54 }
SetUp()55 void SetUp() {};
TearDown()56 void TearDown() {};
57 };
58
59 /**
60 * @tc.number: SUB_DriverSystem_Manager_0010
61 * @tc.name: open input device test
62 * @tc.size: Medium
63 * @tc.level: level 1
64 */
65 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest001, Function | MediumTest | Level1)
66 {
67 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
68 ASSERT_TRUE(servmgr != nullptr);
69 HDIServiceManagerRelease(servmgr);
70 }
71
72 /**
73 * @tc.number: SUB_DriverSystem_Manager_0020
74 * @tc.name: open input device test
75 * @tc.size: Medium
76 * @tc.level: level 1
77 */
78 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest002, Function | MediumTest | Level1)
79 {
80 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
81 ASSERT_TRUE(servmgr != nullptr);
82
83 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
84 HDIServiceManagerRelease(servmgr);
85 ASSERT_TRUE(sampleService != nullptr);
86
87 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
88 ASSERT_EQ(ret, true);
89
90 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
91 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
92 ASSERT_TRUE(data != nullptr);
93 ASSERT_TRUE(reply != nullptr);
94 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
95 ASSERT_EQ(ret, true);
96
97 ret = HdfSbufWriteString(data, "sample_service test call");
98 ASSERT_EQ(ret, true);
99
100 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_SERVICE_PING, data, reply);
101 ASSERT_EQ(status, 0);
102
103 HdfSbufRecycle(data);
104 HdfSbufRecycle(reply);
105 }
106
107 static int32_t g_callbackPayload = 0;
108
ServiceManagerTestCallbackDispatch(struct HdfRemoteService * service,int code,struct HdfSBuf * data,struct HdfSBuf * reply)109 static int ServiceManagerTestCallbackDispatch(
110 struct HdfRemoteService *service, int code, struct HdfSBuf *data, struct HdfSBuf *reply)
111 {
112 HDF_LOGI("ServiceManagerTestCallbackDispatch called, code = %{public}d", code);
113 HdfSbufReadInt32(data, &g_callbackPayload);
114 return HDF_SUCCESS;
115 }
116
117 static struct HdfRemoteDispatcher g_callbackDispatcher {
118 .Dispatch = ServiceManagerTestCallbackDispatch,
119 };
120
121 /**
122 * @tc.number: SUB_DriverSystem_Manager_0030
123 * @tc.name: open input device test
124 * @tc.size: Medium
125 * @tc.level: level 1
126 */
127 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest003, Function | MediumTest | Level1)
128 {
129 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
130 ASSERT_TRUE(servmgr != nullptr);
131
132 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
133 HDIServiceManagerRelease(servmgr);
134 ASSERT_TRUE(sampleService != nullptr);
135 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
136 ASSERT_EQ(ret, true);
137
138 struct HdfRemoteService *callback = HdfRemoteServiceObtain(nullptr, &g_callbackDispatcher);
139 ASSERT_NE(callback, nullptr);
140 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
141 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
142 ASSERT_TRUE(data != nullptr);
143 ASSERT_TRUE(reply != nullptr);
144 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
145 ASSERT_EQ(ret, true);
146 int32_t payload = PAYLOAD_NUM;
147 HdfSbufWriteInt32(data, payload);
148 HdfSbufWriteRemoteService(data, callback);
149
150 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_SERVICE_CALLBACK, data, reply);
151 ASSERT_EQ(status, 0);
152 ASSERT_EQ(g_callbackPayload, payload);
153
154 HdfSbufRecycle(data);
155 HdfSbufRecycle(reply);
156 }
157
158 /**
159 * @tc.number: SUB_DriverSystem_Manager_0040
160 * @tc.name: open input device test
161 * @tc.size: Medium
162 * @tc.level: level 1
163 */
164 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest004, Function | MediumTest | Level1)
165 {
166 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
167 ASSERT_TRUE(servmgr != nullptr);
168
169 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
170 HDIServiceManagerRelease(servmgr);
171 ASSERT_TRUE(sampleService != nullptr);
172 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
173 ASSERT_EQ(ret, true);
174
175 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
176 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
177 ASSERT_TRUE(data != nullptr);
178 ASSERT_TRUE(reply != nullptr);
179 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
180 ASSERT_EQ(ret, true);
181 HdfSbufWriteInt32(data, PAYLOAD_NUM);
182 HdfSbufWriteInt32(data, PAYLOAD_NUM);
183
184 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_SERVICE_SUM, data, reply);
185 ASSERT_EQ(status, 0);
186 int32_t result;
187 ret = HdfSbufReadInt32(reply, &result);
188 ASSERT_TRUE(ret);
189
190 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
191 ASSERT_EQ(result, expRes);
192
193 HdfSbufRecycle(data);
194 HdfSbufRecycle(reply);
195 }
196
197 /**
198 * @tc.number: SUB_DriverSystem_Manager_0050
199 * @tc.name: open input device test
200 * @tc.size: Medium
201 * @tc.level: level 1
202 */
203 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest005, Function | MediumTest | Level1)
204 {
205 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
206 ASSERT_TRUE(servmgr != nullptr);
207
208 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
209 HDIServiceManagerRelease(servmgr);
210 ASSERT_TRUE(sampleService != nullptr);
211 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
212 ASSERT_EQ(ret, true);
213
214 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
215 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
216 ASSERT_TRUE(data != nullptr);
217 ASSERT_TRUE(reply != nullptr);
218 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
219 ASSERT_EQ(ret, true);
220 struct DataBlock dataBlock = {1, 2, "dataBolck", 3};
221 ret = DataBlockBlockMarshalling(&dataBlock, data);
222 ASSERT_TRUE(ret);
223
224 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_STRUCT_TRANS, data, reply);
225 ASSERT_EQ(status, 0);
226
227 struct DataBlock *dataBlock_ = DataBlockBlockUnmarshalling(reply);
228 ASSERT_TRUE(dataBlock_ != nullptr);
229
230 ASSERT_EQ(dataBlock_->a, dataBlock.a);
231 ASSERT_EQ(dataBlock_->b, dataBlock.b);
232 ASSERT_EQ(dataBlock_->c, dataBlock.c);
233 ASSERT_TRUE(!strcmp(dataBlock_->str, dataBlock.str));
234 DataBlockFree(dataBlock_);
235
236 HdfSbufRecycle(data);
237 HdfSbufRecycle(reply);
238 }
239
240 /**
241 * @tc.number: SUB_DriverSystem_Manager_0060
242 * @tc.name: open input device test
243 * @tc.size: Medium
244 * @tc.level: level 1
245 */
246 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest006, Function | MediumTest | Level1)
247 {
248 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
249 ASSERT_TRUE(servmgr != nullptr);
250
251 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
252 HDIServiceManagerRelease(servmgr);
253 ASSERT_TRUE(sampleService != nullptr);
254 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
255 ASSERT_EQ(ret, true);
256
257 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
258 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
259 ASSERT_TRUE(data != nullptr);
260 ASSERT_TRUE(reply != nullptr);
261
262 constexpr int buffersize = 10;
263 uint8_t dataBuffer[buffersize];
264 for (int i = 0; i < buffersize; i++) {
265 dataBuffer[i] = i;
266 }
267 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
268 ASSERT_EQ(ret, true);
269 ret = HdfSbufWriteUnpadBuffer(data, dataBuffer, sizeof(dataBuffer));
270 ASSERT_TRUE(ret);
271
272 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_BUFFER_TRANS, data, reply);
273 ASSERT_EQ(status, 0);
274
275 const uint8_t *retBuffer = HdfSbufReadUnpadBuffer(reply, buffersize);
276 ASSERT_TRUE(retBuffer != nullptr);
277
278 for (int i = 0; i < buffersize; i++) {
279 ASSERT_EQ(retBuffer[i], i);
280 }
281
282 HdfSbufRecycle(data);
283 HdfSbufRecycle(reply);
284 }
285
286 /**
287 * @tc.number: SUB_DriverSystem_Manager_0070
288 * @tc.name: open input device test
289 * @tc.size: Medium
290 * @tc.level: level 1
291 */
292 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest007, Function | MediumTest | Level1)
293 {
294 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
295 ASSERT_TRUE(devmgr != nullptr);
296 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
297
298 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
299 ASSERT_TRUE(servmgr != nullptr);
300 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
301 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
302 ASSERT_TRUE(sampleService == nullptr);
303
304 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
305 ASSERT_EQ(ret, HDF_SUCCESS);
306 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
307 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
308 ASSERT_TRUE(sampleService != nullptr);
309 ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
310 ASSERT_EQ(ret, true);
311
312 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
313 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
314 ASSERT_TRUE(data != nullptr);
315 ASSERT_TRUE(reply != nullptr);
316
317 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
318 ASSERT_EQ(ret, true);
319 const char *newServName = "sample_driver_service2";
320 ret = HdfSbufWriteString(data, newServName);
321 ASSERT_TRUE(ret);
322
323 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_REGISTER_DEVICE, data, reply);
324 ASSERT_EQ(status, HDF_SUCCESS);
325
326 struct HdfRemoteService *sampleService2 = servmgr->GetService(servmgr, newServName);
327 ASSERT_TRUE(sampleService != nullptr);
328 ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
329 ASSERT_EQ(ret, true);
330
331 HdfSbufFlush(data);
332 HdfSbufFlush(reply);
333 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
334 ASSERT_EQ(ret, true);
335 HdfSbufWriteInt32(data, PAYLOAD_NUM);
336 HdfSbufWriteInt32(data, PAYLOAD_NUM);
337
338 status = sampleService2->dispatcher->Dispatch(sampleService2, SAMPLE_SERVICE_SUM, data, reply);
339 ASSERT_EQ(status, 0);
340 int32_t result;
341 ret = HdfSbufReadInt32(reply, &result);
342 ASSERT_TRUE(ret);
343
344 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
345 ASSERT_EQ(result, expRes);
346 HdfRemoteServiceRecycle(sampleService2);
347
348 HdfSbufFlush(data);
349 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
350 ASSERT_EQ(ret, true);
351 ret = HdfSbufWriteString(data, newServName);
352 ASSERT_TRUE(ret);
353
354 status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_UNREGISTER_DEVICE, data, reply);
355 ASSERT_EQ(status, HDF_SUCCESS);
356
357 sampleService2 = servmgr->GetService(servmgr, newServName);
358 ASSERT_TRUE(sampleService2 == nullptr);
359
360 ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
361 ASSERT_EQ(ret, HDF_SUCCESS);
362
363 HdfRemoteServiceRecycle(sampleService);
364 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
365 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
366 ASSERT_TRUE(sampleService == nullptr);
367
368 HdfSbufRecycle(data);
369 HdfSbufRecycle(reply);
370 }
371
372 struct ServiceStatusData {
ServiceStatusDataServiceStatusData373 ServiceStatusData() : devClass(0), servStatus(0), callbacked(false), waitStatus(SERVIE_STATUS_START) {}
374 ~ServiceStatusData() = default;
375 std::string servInfo;
376 uint16_t devClass;
377 uint16_t servStatus;
378 bool callbacked;
379 uint16_t waitStatus;
380 };
381
TestOnServiceStatusReceived(struct ServiceStatusListener * listener,struct ServiceStatus * servstat)382 static void TestOnServiceStatusReceived(struct ServiceStatusListener *listener, struct ServiceStatus *servstat)
383 {
384 struct ServiceStatusData *ssd = (struct ServiceStatusData *)listener->priv;
385 if (ssd == nullptr) {
386 return;
387 }
388 if (strcmp(servstat->serviceName, TEST_SERVICE_NAME) == 0 && (servstat->status == ssd->waitStatus)) {
389 ssd->servInfo = ((servstat->info != nullptr) ? (servstat->info) : (""));
390 ssd->devClass = servstat->deviceClass;
391 ssd->servStatus = servstat->status;
392 ssd->callbacked = true;
393 }
394
395 HDF_LOGI("service status listener callback: %{public}s, %{public}d", servstat->serviceName, servstat->status);
396 }
397
398 /**
399 * @tc.number: SUB_DriverSystem_PnpManager_0040
400 * @tc.name: Test service start status listener
401 * @tc.size: Medium
402 * @tc.level: level 1
403 */
404 HWTEST_F(HdfServiceMangerHdiCTest, SUB_DriverSystem_PnpManager_0040, Function | MediumTest | Level1)
405 {
406 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
407 ASSERT_TRUE(devmgr != nullptr);
408 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
409
410 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
411 ASSERT_TRUE(servmgr != nullptr);
412 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
413 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
414 ASSERT_TRUE(sampleService == nullptr);
415
416 struct ServiceStatusData ssd;
417 ssd.waitStatus = SERVIE_STATUS_START;
418 struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
419 listener->callback = TestOnServiceStatusReceived;
420 listener->priv = (void *)&ssd;
421
422 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
423 ASSERT_EQ(status, HDF_SUCCESS);
424
425 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
426 ASSERT_EQ(ret, HDF_SUCCESS);
427 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
428 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
429 ASSERT_TRUE(sampleService != nullptr);
430
431 constexpr int WAIT_COUNT = 300;
432 int count = WAIT_COUNT;
433 while (!ssd.callbacked && count > 0) {
434 OsalMSleep(1);
435 count--;
436 }
437
438 ASSERT_TRUE(ssd.callbacked);
439 ASSERT_EQ(ssd.devClass, DEVICE_CLASS_DEFAULT);
440 ASSERT_EQ(ssd.servInfo, std::string(TEST_SERVICE_NAME));
441 ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_START);
442
443 ssd.callbacked = false;
444 ssd.waitStatus = SERVIE_STATUS_STOP;
445 ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
446 ASSERT_EQ(ret, HDF_SUCCESS);
447
448 count = WAIT_COUNT;
449 while (!ssd.callbacked && count > 0) {
450 OsalMSleep(1);
451 count--;
452 }
453 ASSERT_TRUE(ssd.callbacked);
454 ASSERT_EQ(ssd.devClass, DEVICE_CLASS_DEFAULT);
455 ASSERT_EQ(ssd.servInfo, std::string(TEST_SERVICE_NAME));
456 ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_STOP);
457
458 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
459 ASSERT_EQ(status, HDF_SUCCESS);
460
461 HdiServiceStatusListenerFree(listener);
462 }
463
464 /**
465 * @tc.number: SUB_DriverSystem_PnpManager_0060
466 * @tc.name: Test service status listener update service info
467 * @tc.size: Medium
468 * @tc.level: level 1
469 */
470 HWTEST_F(HdfServiceMangerHdiCTest, SUB_DriverSystem_PnpManager_0060, Function | MediumTest | Level1)
471 {
472 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
473 ASSERT_TRUE(devmgr != nullptr);
474 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
475 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
476 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
477 ASSERT_TRUE(servmgr != nullptr);
478
479 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
480 ASSERT_TRUE(sampleService == nullptr);
481
482 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
483 ASSERT_EQ(ret, HDF_SUCCESS);
484 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
485 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
486 ASSERT_TRUE(sampleService != nullptr);
487 bool res = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
488 ASSERT_EQ(res, true);
489
490 struct ServiceStatusData ssd;
491 struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
492 listener->callback = TestOnServiceStatusReceived;
493 listener->priv = (void *)&ssd;
494
495 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
496 ASSERT_EQ(status, HDF_SUCCESS);
497 constexpr int FIRST_WAIT = 20;
498 OsalMSleep(FIRST_WAIT); // skip callback on register
499
500 std::string info = "foo";
501 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
502 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
503 ASSERT_TRUE(data != nullptr);
504 ASSERT_TRUE(reply != nullptr);
505 res = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
506 ASSERT_EQ(res, true);
507 res = HdfSbufWriteString(data, info.data());
508 ASSERT_TRUE(res);
509
510 ssd.callbacked = false;
511 ssd.waitStatus = SERVIE_STATUS_CHANGE;
512 status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_UPDATE_SERVIE, data, reply);
513 ASSERT_EQ(status, HDF_SUCCESS);
514
515 constexpr int WAIT_COUNT = 100;
516 int count = WAIT_COUNT;
517 while (!ssd.callbacked && count > 0) {
518 OsalMSleep(1);
519 count--;
520 }
521 ASSERT_TRUE(ssd.callbacked);
522 ASSERT_EQ(ssd.devClass, DEVICE_CLASS_DEFAULT);
523 ASSERT_EQ(ssd.servInfo, info);
524 ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_CHANGE);
525
526 ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
527 ASSERT_EQ(ret, HDF_SUCCESS);
528
529 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
530 ASSERT_EQ(status, HDF_SUCCESS);
531
532 HdiServiceStatusListenerFree(listener);
533 }
534
535 /**
536 * @tc.number: SUB_DriverSystem_PnpManager_0030
537 * @tc.name: Test service status listener unregister
538 * @tc.size: Medium
539 * @tc.level: level 1
540 */
541 HWTEST_F(HdfServiceMangerHdiCTest, SUB_DriverSystem_PnpManager_0030, Function | MediumTest | Level1)
542 {
543 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
544 ASSERT_TRUE(devmgr != nullptr);
545 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
546
547 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
548 ASSERT_TRUE(servmgr != nullptr);
549 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
550 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
551 ASSERT_TRUE(sampleService == nullptr);
552
553 struct ServiceStatusData ssd;
554 ssd.waitStatus = SERVIE_STATUS_START;
555 struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
556 listener->callback = TestOnServiceStatusReceived;
557 listener->priv = (void *)&ssd;
558
559 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
560 ASSERT_EQ(status, HDF_SUCCESS);
561
562 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
563 ASSERT_EQ(ret, HDF_SUCCESS);
564
565 constexpr int WAIT_COUNT = 300;
566 int count = WAIT_COUNT;
567 while (!ssd.callbacked && count > 0) {
568 OsalMSleep(1);
569 count--;
570 }
571 ASSERT_TRUE(ssd.callbacked);
572 ASSERT_EQ(ssd.devClass, DEVICE_CLASS_DEFAULT);
573 ASSERT_EQ(ssd.servInfo, std::string(TEST_SERVICE_NAME));
574 ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_START);
575
576 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
577 ASSERT_TRUE(sampleService != nullptr);
578
579 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
580 ASSERT_EQ(status, HDF_SUCCESS);
581 HdiServiceStatusListenerFree(listener);
582
583 ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
584 ASSERT_EQ(ret, HDF_SUCCESS);
585
586 ssd.callbacked = false;
587 OsalMSleep(WAIT_COUNT);
588 ASSERT_FALSE(ssd.callbacked);
589 }
590
591 /**
592 * @tc.number: SUB_DriverSystem_MemoryHdi_0040
593 * @tc.name: Test shared mem interfac
594 * @tc.size: Medium
595 * @tc.level: level 1
596 */
597 HWTEST_F(HdfServiceMangerHdiCTest, SUB_DriverSystem_MemoryHdi_0040, Function | MediumTest | Level1)
598 {
599 constexpr int mapSize = 128;
600 int memFd = SharedMemCreate("shared_mem_test", mapSize);
601 ASSERT_TRUE(memFd >= 0);
602
603 void *ptr = mmap(nullptr, mapSize, PROT_READ | PROT_WRITE, MAP_SHARED, memFd, 0);
604 ASSERT_NE(ptr, MAP_FAILED);
605
606 uint8_t *data = reinterpret_cast<uint8_t *>(ptr);
607 for (int i = 0; i < mapSize; i++) {
608 data[i] = i;
609 }
610
611 for (int i = 0; i < mapSize; i++) {
612 ASSERT_EQ(data[i], i);
613 }
614
615 auto ret = munmap(ptr, mapSize);
616 ASSERT_EQ(ret, 0);
617
618 close(memFd);
619 }