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 #include "hdi_support.h"
31
32 #define HDF_LOG_TAG service_manager_test
33
34 namespace OHOS {
35 using namespace testing::ext;
36
37 static constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
38 static constexpr const char *TEST1_SERVICE_NAME = "sample1_driver_service";
39 static constexpr const char *TEST_SERVICE_INTERFACE_DESC = "hdf.test.sampele_service";
40 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_INVALID = "____";
41 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_VOID = "";
42 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_NULL = nullptr;
43 static constexpr int PAYLOAD_NUM = 1234;
44 static constexpr int WAIT_LOAD_UNLOAD_TIME = 300;
45 class HdfServiceMangerHdiCTest : public testing::Test {
46 public:
SetUpTestCase()47 static void SetUpTestCase()
48 {
49 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
50 if (devmgr != nullptr) {
51 devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
52 }
53 }
TearDownTestCase()54 static void TearDownTestCase()
55 {
56 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
57 if (devmgr != nullptr) {
58 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
59 }
60 }
SetUp()61 void SetUp() {};
TearDown()62 void TearDown() {};
63 };
64
65 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest001, TestSize.Level1)
66 {
67 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
68 ASSERT_TRUE(servmgr != nullptr);
69 HDIServiceManagerRelease(servmgr);
70 }
71
72 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest002, TestSize.Level1)
73 {
74 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
75 ASSERT_TRUE(servmgr != nullptr);
76
77 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
78 HDIServiceManagerRelease(servmgr);
79 ASSERT_TRUE(sampleService != nullptr);
80
81 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
82 ASSERT_EQ(ret, true);
83
84 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
85 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
86 ASSERT_TRUE(data != nullptr);
87 ASSERT_TRUE(reply != nullptr);
88 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
89 ASSERT_EQ(ret, true);
90
91 ret = HdfSbufWriteString(data, "sample_service test call");
92 ASSERT_EQ(ret, true);
93
94 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_SERVICE_PING, data, reply);
95 ASSERT_EQ(status, 0);
96
97 HdfSbufRecycle(data);
98 HdfSbufRecycle(reply);
99 }
100
101 static int32_t g_callbackPayload = 0;
102
ServiceManagerTestCallbackDispatch(struct HdfRemoteService * service,int code,struct HdfSBuf * data,struct HdfSBuf * reply)103 static int ServiceManagerTestCallbackDispatch(
104 struct HdfRemoteService *service, int code, struct HdfSBuf *data, struct HdfSBuf *reply)
105 {
106 HDF_LOGI("ServiceManagerTestCallbackDispatch called, code = %{public}d", code);
107 HdfSbufReadInt32(data, &g_callbackPayload);
108 return HDF_SUCCESS;
109 }
110
111 static struct HdfRemoteDispatcher g_callbackDispatcher {
112 .Dispatch = ServiceManagerTestCallbackDispatch,
113 };
114
115 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest003, TestSize.Level1)
116 {
117 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
118 ASSERT_TRUE(servmgr != nullptr);
119
120 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
121 HDIServiceManagerRelease(servmgr);
122 ASSERT_TRUE(sampleService != nullptr);
123 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
124 ASSERT_EQ(ret, true);
125
126 struct HdfRemoteService *callback = HdfRemoteServiceObtain(nullptr, &g_callbackDispatcher);
127 ASSERT_NE(callback, nullptr);
128 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
129 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
130 ASSERT_TRUE(data != nullptr);
131 ASSERT_TRUE(reply != nullptr);
132 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
133 ASSERT_EQ(ret, true);
134 int32_t payload = PAYLOAD_NUM;
135 HdfSbufWriteInt32(data, payload);
136 HdfSbufWriteRemoteService(data, callback);
137
138 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_SERVICE_CALLBACK, data, reply);
139 ASSERT_EQ(status, 0);
140 ASSERT_EQ(g_callbackPayload, payload);
141
142 HdfSbufRecycle(data);
143 HdfSbufRecycle(reply);
144 }
145
146 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest004, TestSize.Level1)
147 {
148 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
149 ASSERT_TRUE(servmgr != nullptr);
150
151 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
152 HDIServiceManagerRelease(servmgr);
153 ASSERT_TRUE(sampleService != nullptr);
154 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
155 ASSERT_EQ(ret, true);
156
157 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
158 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
159 ASSERT_TRUE(data != nullptr);
160 ASSERT_TRUE(reply != nullptr);
161 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
162 ASSERT_EQ(ret, true);
163 HdfSbufWriteInt32(data, PAYLOAD_NUM);
164 HdfSbufWriteInt32(data, PAYLOAD_NUM);
165
166 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_SERVICE_SUM, data, reply);
167 ASSERT_EQ(status, 0);
168 int32_t result;
169 ret = HdfSbufReadInt32(reply, &result);
170 ASSERT_TRUE(ret);
171
172 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
173 ASSERT_EQ(result, expRes);
174
175 HdfSbufRecycle(data);
176 HdfSbufRecycle(reply);
177 }
178
179 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest005, TestSize.Level1)
180 {
181 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
182 ASSERT_TRUE(servmgr != nullptr);
183
184 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
185 HDIServiceManagerRelease(servmgr);
186 ASSERT_TRUE(sampleService != nullptr);
187 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
188 ASSERT_EQ(ret, true);
189
190 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
191 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
192 ASSERT_TRUE(data != nullptr);
193 ASSERT_TRUE(reply != nullptr);
194 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
195 ASSERT_EQ(ret, true);
196 struct DataBlock dataBlock = {1, 2, "dataBolck", 3};
197 ret = DataBlockBlockMarshalling(&dataBlock, data);
198 ASSERT_TRUE(ret);
199
200 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_STRUCT_TRANS, data, reply);
201 ASSERT_EQ(status, 0);
202
203 struct DataBlock *dataBlock_ = DataBlockBlockUnmarshalling(reply);
204 ASSERT_TRUE(dataBlock_ != nullptr);
205
206 ASSERT_EQ(dataBlock_->a, dataBlock.a);
207 ASSERT_EQ(dataBlock_->b, dataBlock.b);
208 ASSERT_EQ(dataBlock_->c, dataBlock.c);
209 ASSERT_TRUE(!strcmp(dataBlock_->str, dataBlock.str));
210 DataBlockFree(dataBlock_);
211
212 HdfSbufRecycle(data);
213 HdfSbufRecycle(reply);
214 }
215
216 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest006, TestSize.Level1)
217 {
218 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
219 ASSERT_TRUE(servmgr != nullptr);
220
221 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
222 HDIServiceManagerRelease(servmgr);
223 ASSERT_TRUE(sampleService != nullptr);
224 bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
225 ASSERT_EQ(ret, true);
226
227 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
228 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
229 ASSERT_TRUE(data != nullptr);
230 ASSERT_TRUE(reply != nullptr);
231
232 constexpr int buffersize = 10;
233 uint8_t dataBuffer[buffersize];
234 for (int i = 0; i < buffersize; i++) {
235 dataBuffer[i] = i;
236 }
237 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
238 ASSERT_EQ(ret, true);
239 ret = HdfSbufWriteUnpadBuffer(data, dataBuffer, sizeof(dataBuffer));
240 ASSERT_TRUE(ret);
241
242 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_BUFFER_TRANS, data, reply);
243 ASSERT_EQ(status, 0);
244
245 const uint8_t *retBuffer = HdfSbufReadUnpadBuffer(reply, buffersize);
246 ASSERT_TRUE(retBuffer != nullptr);
247
248 for (int i = 0; i < buffersize; i++) {
249 ASSERT_EQ(retBuffer[i], i);
250 }
251
252 HdfSbufRecycle(data);
253 HdfSbufRecycle(reply);
254 }
255
256 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest007, TestSize.Level1)
257 {
258 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
259 ASSERT_TRUE(devmgr != nullptr);
260 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
261
262 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
263 ASSERT_TRUE(servmgr != nullptr);
264 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
265 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
266 ASSERT_TRUE(sampleService == nullptr);
267
268 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
269 ASSERT_EQ(ret, HDF_SUCCESS);
270 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
271 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
272 ASSERT_TRUE(sampleService != nullptr);
273 ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
274 ASSERT_EQ(ret, true);
275
276 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
277 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
278 ASSERT_TRUE(data != nullptr);
279 ASSERT_TRUE(reply != nullptr);
280
281 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
282 ASSERT_EQ(ret, true);
283 const char *newServName = "sample_driver_service2";
284 ret = HdfSbufWriteString(data, newServName);
285 ASSERT_TRUE(ret);
286
287 int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_REGISTER_DEVICE, data, reply);
288 ASSERT_EQ(status, HDF_SUCCESS);
289
290 struct HdfRemoteService *sampleService2 = servmgr->GetService(servmgr, newServName);
291 ASSERT_TRUE(sampleService != nullptr);
292 ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
293 ASSERT_EQ(ret, true);
294
295 HdfSbufFlush(data);
296 HdfSbufFlush(reply);
297 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
298 ASSERT_EQ(ret, true);
299 HdfSbufWriteInt32(data, PAYLOAD_NUM);
300 HdfSbufWriteInt32(data, PAYLOAD_NUM);
301
302 status = sampleService2->dispatcher->Dispatch(sampleService2, SAMPLE_SERVICE_SUM, data, reply);
303 ASSERT_EQ(status, 0);
304 int32_t result;
305 ret = HdfSbufReadInt32(reply, &result);
306 ASSERT_TRUE(ret);
307
308 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
309 ASSERT_EQ(result, expRes);
310 HdfRemoteServiceRecycle(sampleService2);
311
312 HdfSbufFlush(data);
313 ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
314 ASSERT_EQ(ret, true);
315 ret = HdfSbufWriteString(data, newServName);
316 ASSERT_TRUE(ret);
317
318 status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_UNREGISTER_DEVICE, data, reply);
319 ASSERT_EQ(status, HDF_SUCCESS);
320
321 sampleService2 = servmgr->GetService(servmgr, newServName);
322 ASSERT_TRUE(sampleService2 == nullptr);
323
324 ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
325 ASSERT_EQ(ret, HDF_SUCCESS);
326
327 HdfRemoteServiceRecycle(sampleService);
328 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
329 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
330 ASSERT_TRUE(sampleService == nullptr);
331
332 HdfSbufRecycle(data);
333 HdfSbufRecycle(reply);
334 }
335
336 struct ServiceStatusData {
ServiceStatusDataOHOS::ServiceStatusData337 ServiceStatusData() : devClass(0), servStatus(0), callbacked(false), waitStatus(SERVIE_STATUS_START) {}
338 ~ServiceStatusData() = default;
339 std::string servInfo;
340 uint16_t devClass;
341 uint16_t servStatus;
342 bool callbacked;
343 uint16_t waitStatus;
344 };
345
TestOnServiceStatusReceived(struct ServiceStatusListener * listener,struct ServiceStatus * servstat)346 static void TestOnServiceStatusReceived(struct ServiceStatusListener *listener, struct ServiceStatus *servstat)
347 {
348 struct ServiceStatusData *ssd = static_cast<struct ServiceStatusData *>(listener->priv);
349 if (ssd == nullptr) {
350 return;
351 }
352 if (strcmp(servstat->serviceName, TEST_SERVICE_NAME) == 0 && (servstat->status == ssd->waitStatus)) {
353 ssd->servInfo = ((servstat->info != nullptr) ? (servstat->info) : (""));
354 ssd->devClass = servstat->deviceClass;
355 ssd->servStatus = servstat->status;
356 ssd->callbacked = true;
357 }
358
359 HDF_LOGI("service status listener callback: %{public}s, %{public}d", servstat->serviceName, servstat->status);
360 }
361
362 /*
363 * Test service start status listener
364 */
365 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest008, TestSize.Level1)
366 {
367 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
368 ASSERT_TRUE(devmgr != nullptr);
369 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
370
371 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
372 ASSERT_TRUE(servmgr != nullptr);
373 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
374 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
375 ASSERT_TRUE(sampleService == nullptr);
376
377 struct ServiceStatusData ssd;
378 ssd.waitStatus = SERVIE_STATUS_START;
379 struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
380 listener->callback = TestOnServiceStatusReceived;
381 listener->priv = static_cast<void *>(&ssd);
382
383 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
384 ASSERT_EQ(status, HDF_SUCCESS);
385
386 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
387 ASSERT_EQ(ret, HDF_SUCCESS);
388 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
389 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
390 ASSERT_TRUE(sampleService != nullptr);
391
392 constexpr int WAIT_COUNT = 300;
393 int count = WAIT_COUNT;
394 while (!ssd.callbacked && count > 0) {
395 OsalMSleep(1);
396 count--;
397 }
398
399 ASSERT_TRUE(ssd.callbacked);
400 ASSERT_EQ(ssd.devClass, DEVICE_CLASS_DEFAULT);
401 ASSERT_EQ(ssd.servInfo, std::string(TEST_SERVICE_NAME));
402 ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_START);
403
404 ssd.callbacked = false;
405 ssd.waitStatus = SERVIE_STATUS_STOP;
406 ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
407 ASSERT_EQ(ret, HDF_SUCCESS);
408
409 count = WAIT_COUNT;
410 while (!ssd.callbacked && count > 0) {
411 OsalMSleep(1);
412 count--;
413 }
414 ASSERT_TRUE(ssd.callbacked);
415 ASSERT_EQ(ssd.devClass, DEVICE_CLASS_DEFAULT);
416 ASSERT_EQ(ssd.servInfo, std::string(TEST_SERVICE_NAME));
417 ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_STOP);
418
419 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
420 ASSERT_EQ(status, HDF_SUCCESS);
421
422 HdiServiceStatusListenerFree(listener);
423 }
424
425 /*
426 * Test service status listener update service info
427 */
428 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest009, TestSize.Level1)
429 {
430 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
431 ASSERT_TRUE(devmgr != nullptr);
432 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
433 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
434 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
435 ASSERT_TRUE(servmgr != nullptr);
436
437 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
438 ASSERT_TRUE(sampleService == nullptr);
439
440 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
441 ASSERT_EQ(ret, HDF_SUCCESS);
442 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
443 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
444 ASSERT_TRUE(sampleService != nullptr);
445 bool res = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
446 ASSERT_EQ(res, true);
447
448 struct ServiceStatusData ssd;
449 struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
450 listener->callback = TestOnServiceStatusReceived;
451 listener->priv = static_cast<void *>(&ssd);
452
453 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
454 ASSERT_EQ(status, HDF_SUCCESS);
455 constexpr int FIRST_WAIT = 20;
456 OsalMSleep(FIRST_WAIT); // skip callback on register
457
458 std::string info = "foo";
459 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
460 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
461 ASSERT_TRUE(data != nullptr);
462 ASSERT_TRUE(reply != nullptr);
463 res = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
464 ASSERT_EQ(res, true);
465 res = HdfSbufWriteString(data, info.data());
466 ASSERT_TRUE(res);
467
468 ssd.callbacked = false;
469 ssd.waitStatus = SERVIE_STATUS_CHANGE;
470 status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_UPDATE_SERVIE, data, reply);
471 ASSERT_EQ(status, HDF_SUCCESS);
472
473 constexpr int WAIT_COUNT = 100;
474 int count = WAIT_COUNT;
475 while (!ssd.callbacked && count > 0) {
476 OsalMSleep(1);
477 count--;
478 }
479 ASSERT_TRUE(ssd.callbacked);
480 ASSERT_EQ(ssd.devClass, DEVICE_CLASS_DEFAULT);
481 ASSERT_EQ(ssd.servInfo, info);
482 ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_CHANGE);
483
484 ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
485 ASSERT_EQ(ret, HDF_SUCCESS);
486
487 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
488 ASSERT_EQ(status, HDF_SUCCESS);
489
490 HdiServiceStatusListenerFree(listener);
491 }
492
493 /*
494 * Test service status listener unregister
495 */
496 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest010, TestSize.Level1)
497 {
498 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
499 ASSERT_TRUE(devmgr != nullptr);
500 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
501
502 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
503 ASSERT_TRUE(servmgr != nullptr);
504 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
505 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
506 ASSERT_TRUE(sampleService == nullptr);
507
508 struct ServiceStatusData ssd;
509 ssd.waitStatus = SERVIE_STATUS_START;
510 struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
511 listener->callback = TestOnServiceStatusReceived;
512 listener->priv = static_cast<void *>(&ssd);
513
514 int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
515 ASSERT_EQ(status, HDF_SUCCESS);
516
517 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
518 ASSERT_EQ(ret, HDF_SUCCESS);
519
520 constexpr int WAIT_COUNT = 300;
521 int count = WAIT_COUNT;
522 while (!ssd.callbacked && count > 0) {
523 OsalMSleep(1);
524 count--;
525 }
526 ASSERT_TRUE(ssd.callbacked);
527 ASSERT_EQ(ssd.devClass, DEVICE_CLASS_DEFAULT);
528 ASSERT_EQ(ssd.servInfo, std::string(TEST_SERVICE_NAME));
529 ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_START);
530
531 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
532 ASSERT_TRUE(sampleService != nullptr);
533
534 status = servmgr->UnregisterServiceStatusListener(servmgr, listener);
535 ASSERT_EQ(status, HDF_SUCCESS);
536 HdiServiceStatusListenerFree(nullptr);
537 HdiServiceStatusListenerFree(listener);
538
539 ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
540 ASSERT_EQ(ret, HDF_SUCCESS);
541
542 ssd.callbacked = false;
543 OsalMSleep(WAIT_COUNT);
544 ASSERT_FALSE(ssd.callbacked);
545 }
546
547 /*
548 * Test shared mem interface
549 */
550 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest011, TestSize.Level1)
551 {
552 constexpr int mapSize = 128;
553 int memFd = SharedMemCreate("shared_mem_test", mapSize);
554 ASSERT_TRUE(memFd >= 0);
555
556 void *ptr = mmap(nullptr, mapSize, PROT_READ | PROT_WRITE, MAP_SHARED, memFd, 0);
557 ASSERT_NE(ptr, MAP_FAILED);
558
559 uint8_t *data = static_cast<uint8_t *>(ptr);
560 for (int i = 0; i < mapSize; i++) {
561 data[i] = i;
562 }
563
564 for (int i = 0; i < mapSize; i++) {
565 ASSERT_EQ(data[i], i);
566 }
567
568 int memSize = SharedMemGetSize(memFd);
569 ASSERT_EQ(memSize, mapSize);
570
571 auto ret = munmap(ptr, mapSize);
572 ASSERT_EQ(ret, 0);
573
574 close(memFd);
575 }
576
577 /*
578 * Test get service set by interfacedesc
579 */
580 HWTEST_F(HdfServiceMangerHdiCTest, ListServiceByInterfaceDescTest001, TestSize.Level1)
581 {
582 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
583 ASSERT_TRUE(devmgr != nullptr);
584 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
585 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
586 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
587 ASSERT_TRUE(servmgr != nullptr);
588
589 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
590 ASSERT_TRUE(sampleService == nullptr);
591
592 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
593 ASSERT_EQ(ret, HDF_SUCCESS);
594 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
595 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
596 ASSERT_TRUE(sampleService != nullptr);
597
598 struct HdiServiceSet *serviceSet = servmgr->ListServiceByInterfaceDesc(servmgr, TEST_SERVICE_INTERFACE_DESC);
599 HDIServiceManagerRelease(servmgr);
600 ASSERT_TRUE(serviceSet != nullptr);
601 constexpr int sampleServiceCount = 1;
602 ASSERT_TRUE(serviceSet->count == sampleServiceCount);
603 ASSERT_TRUE(strcmp(serviceSet->serviceNames[0], TEST_SERVICE_NAME) == 0);
604 ret = HdiServiceSetRelease(serviceSet);
605 ASSERT_TRUE(ret == HDF_SUCCESS);
606 }
607
608 HWTEST_F(HdfServiceMangerHdiCTest, ListServiceByInterfaceDescTest002, TestSize.Level1)
609 {
610 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
611 ASSERT_TRUE(servmgr != nullptr);
612
613 struct HdiServiceSet *serviceSet =
614 servmgr->ListServiceByInterfaceDesc(servmgr, TEST_SERVICE_INTERFACE_DESC_INVALID);
615 HDIServiceManagerRelease(servmgr);
616 ASSERT_TRUE(serviceSet == nullptr);
617 }
618
619 HWTEST_F(HdfServiceMangerHdiCTest, ListServiceByInterfaceDescTest003, TestSize.Level1)
620 {
621 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
622 ASSERT_TRUE(servmgr != nullptr);
623
624 struct HdiServiceSet *serviceSet = servmgr->ListServiceByInterfaceDesc(servmgr, TEST_SERVICE_INTERFACE_DESC_VOID);
625 HDIServiceManagerRelease(servmgr);
626 ASSERT_TRUE(serviceSet == nullptr);
627 }
628
629 HWTEST_F(HdfServiceMangerHdiCTest, ListServiceByInterfaceDescTest004, TestSize.Level1)
630 {
631 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
632 ASSERT_TRUE(servmgr != nullptr);
633
634 struct HdiServiceSet *serviceSet = servmgr->ListServiceByInterfaceDesc(servmgr, TEST_SERVICE_INTERFACE_DESC_NULL);
635 HDIServiceManagerRelease(servmgr);
636 ASSERT_TRUE(serviceSet == nullptr);
637 }
638
639 HWTEST_F(HdfServiceMangerHdiCTest, ListServiceByInterfaceDescTest005, TestSize.Level1)
640 {
641 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
642 ASSERT_TRUE(devmgr != nullptr);
643 devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
644 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
645 devmgr->UnloadDevice(devmgr, TEST1_SERVICE_NAME);
646 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
647 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
648 ASSERT_TRUE(servmgr != nullptr);
649
650 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
651 ASSERT_TRUE(sampleService == nullptr);
652 struct HdfRemoteService *sample1Service = servmgr->GetService(servmgr, TEST1_SERVICE_NAME);
653 ASSERT_TRUE(sample1Service == nullptr);
654
655 int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
656 ASSERT_EQ(ret, HDF_SUCCESS);
657 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
658 sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
659 ASSERT_TRUE(sampleService != nullptr);
660
661 ret = devmgr->LoadDevice(devmgr, TEST1_SERVICE_NAME);
662 ASSERT_EQ(ret, HDF_SUCCESS);
663 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
664 sample1Service = servmgr->GetService(servmgr, TEST1_SERVICE_NAME);
665 ASSERT_TRUE(sample1Service != nullptr);
666
667 struct HdiServiceSet *serviceSet = servmgr->ListServiceByInterfaceDesc(servmgr, TEST_SERVICE_INTERFACE_DESC);
668 HDIServiceManagerRelease(servmgr);
669 ASSERT_TRUE(serviceSet != nullptr);
670 constexpr int sampleServiceCount = 2;
671 ASSERT_TRUE(serviceSet->count == sampleServiceCount);
672 ASSERT_TRUE(strcmp(serviceSet->serviceNames[0], TEST_SERVICE_NAME) == 0);
673 ASSERT_TRUE(strcmp(serviceSet->serviceNames[1], TEST1_SERVICE_NAME) == 0);
674 ret = HdiServiceSetRelease(serviceSet);
675 ASSERT_TRUE(ret == HDF_SUCCESS);
676 ret = devmgr->UnloadDevice(devmgr, TEST1_SERVICE_NAME);
677 ASSERT_TRUE(ret == HDF_SUCCESS);
678 HDIDeviceManagerRelease(devmgr);
679 }
680
681 HWTEST_F(HdfServiceMangerHdiCTest, DevMgrQueryUsableDeviceTest, TestSize.Level1)
682 {
683 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
684 ASSERT_TRUE(devmgr != nullptr);
685
686 struct DeviceInfoList list;
687 int32_t ret = devmgr->QueryUsableDeviceInfo(devmgr, &list);
688 ASSERT_TRUE(ret == HDF_SUCCESS);
689
690 devmgr->FreeQueryDeviceList(devmgr, &list);
691 HDIDeviceManagerRelease(devmgr);
692 }
693
694 HWTEST_F(HdfServiceMangerHdiCTest, DevMgrQueryUnusableDeviceTest, TestSize.Level1)
695 {
696 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
697 ASSERT_TRUE(devmgr != nullptr);
698
699 struct DeviceInfoList list;
700 int32_t ret = devmgr->QueryUnusableDeviceInfo(devmgr, &list);
701 ASSERT_TRUE(ret == HDF_SUCCESS);
702
703 devmgr->FreeQueryDeviceList(devmgr, &list);
704 HDIDeviceManagerRelease(devmgr);
705 }
706
707 HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest018, TestSize.Level1)
708 {
709 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
710 ASSERT_TRUE(servmgr != nullptr);
711
712 struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, NULL);
713 ASSERT_TRUE(sampleService == nullptr);
714
715 int status = servmgr->RegisterServiceStatusListener(servmgr, NULL, DEVICE_CLASS_DEFAULT);
716 ASSERT_EQ(status, HDF_ERR_INVALID_PARAM);
717
718 status = servmgr->UnregisterServiceStatusListener(servmgr, NULL);
719 ASSERT_EQ(status, HDF_ERR_INVALID_PARAM);
720
721 status = HdiServiceSetRelease(NULL);
722 ASSERT_TRUE(status == HDF_SUCCESS);
723
724 HDIServiceManagerRelease(servmgr);
725 HDIServiceManagerRelease(NULL);
726 }
727
728 HWTEST_F(HdfServiceMangerHdiCTest, DevMgrTest, TestSize.Level1)
729 {
730 struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
731 ASSERT_TRUE(devmgr != nullptr);
732
733 int ret = devmgr->QueryUnusableDeviceInfo(devmgr, NULL);
734 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
735
736 ret = devmgr->QueryUsableDeviceInfo(devmgr, NULL);
737 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
738
739 ret = devmgr->LoadDevice(devmgr, NULL);
740 ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
741
742 ret = devmgr->UnloadDevice(devmgr, NULL);
743 ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
744
745 devmgr->FreeQueryDeviceList(devmgr, NULL);
746 HDIDeviceManagerRelease(devmgr);
747 HDIDeviceManagerRelease(NULL);
748 }
749
750 HWTEST_F(HdfServiceMangerHdiCTest, HdiSupportTest, TestSize.Level1)
751 {
752 ASSERT_EQ(LoadHdiImpl(NULL, NULL), nullptr);
753 UnloadHdiImpl(NULL, NULL, NULL);
754 }
755 } // namespace OHOS