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