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