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