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