1 /*
2 * Copyright (c) 2022 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 <gtest/gtest.h>
17
18 #include "devhost_service.h"
19 #include "devhost_service_stub.h"
20 #include "devhost_service_proxy.h"
21 #include "devhost_dump.h"
22 #include "devhost_dump_reg.h"
23 #include "device_service_stub.h"
24 #include "devmgr_service_clnt.h"
25 #include "devmgr_service_proxy.h"
26 #include "devsvc_manager_proxy.h"
27 #include "driver_loader_full.h"
28 #include "hdf_cstring.h"
29 #include "hdf_device.h"
30 #include "hdf_device_node.h"
31 #include "hdf_remote_service.h"
32 #include "hdf_log.h"
33 #include "hdf_sbuf.h"
34 #include "osal_mem.h"
35
36 #define HDF_LOG_TAG host_test
37
38 namespace OHOS {
39 using namespace testing::ext;
40
41 class DevHostTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp();
46 void TearDown();
47 };
48
SetUpTestCase()49 void DevHostTest::SetUpTestCase()
50 {
51 }
52
TearDownTestCase()53 void DevHostTest::TearDownTestCase()
54 {
55 }
56
SetUp()57 void DevHostTest::SetUp()
58 {
59 }
60
TearDown()61 void DevHostTest::TearDown()
62 {
63 }
64
65 HWTEST_F(DevHostTest, DevHostDevMgrServiceProxyTest, TestSize.Level1)
66 {
67 struct HdfObject *object = DevmgrServiceProxyCreate();
68 ASSERT_TRUE(object != nullptr);
69 struct IDevmgrService *instance = reinterpret_cast<struct IDevmgrService *>(object);
70
71 int32_t ret = instance->AttachDeviceHost(instance, 0, nullptr);
72 ASSERT_TRUE(ret != HDF_SUCCESS);
73 ret = instance->AttachDevice(instance, nullptr);
74 ASSERT_TRUE(ret != HDF_SUCCESS);
75 ret = instance->LoadDevice(instance, nullptr);
76 ASSERT_TRUE(ret != HDF_SUCCESS);
77
78 struct DevmgrServiceProxy *proxy = reinterpret_cast<struct DevmgrServiceProxy *>(object);
79 HdfRemoteServiceRecycle(proxy->remote);
80 proxy->remote = nullptr;
81
82 ret = instance->AttachDeviceHost(instance, 0, nullptr);
83 ASSERT_TRUE(ret != HDF_SUCCESS);
84 ret = instance->AttachDevice(instance, nullptr);
85 ASSERT_TRUE(ret != HDF_SUCCESS);
86 ret = instance->AttachDevice(nullptr, nullptr);
87 ASSERT_TRUE(ret != HDF_SUCCESS);
88 ret = instance->DetachDevice(instance, 0);
89 ASSERT_TRUE(ret != HDF_SUCCESS);
90 ret = instance->DetachDevice(nullptr, 0);
91 ASSERT_TRUE(ret != HDF_SUCCESS);
92 ret = instance->LoadDevice(instance, nullptr);
93 ASSERT_TRUE(ret != HDF_SUCCESS);
94 ret = instance->LoadDevice(nullptr, nullptr);
95 ASSERT_TRUE(ret != HDF_SUCCESS);
96 DevmgrServiceProxyRelease(object);
97 DevmgrServiceProxyRelease(nullptr);
98 }
99
100 HWTEST_F(DevHostTest, DevHostDevSvcMgrProxyTest, TestSize.Level1)
101 {
102 struct HdfObject *object = DevSvcManagerProxyCreate();
103 ASSERT_TRUE(object != nullptr);
104 struct IDevSvcManager *instance = reinterpret_cast<struct IDevSvcManager *>(object);
105 struct HdfDeviceObject device;
106 struct HdfServiceInfo servInfo;
107 servInfo.servName = "test";
108 servInfo.devClass = DEVICE_CLASS_MAX;
109 int32_t ret = instance->AddService(instance, &device, &servInfo);
110 ASSERT_TRUE(ret != HDF_SUCCESS);
111 ret = instance->AddService(instance, nullptr, &servInfo);
112 ASSERT_TRUE(ret != HDF_SUCCESS);
113 ret = instance->UpdateService(instance, &device, &servInfo);
114 ASSERT_TRUE(ret != HDF_SUCCESS);
115
116 servInfo.servName = nullptr;
117 ret = instance->AddService(instance, &device, &servInfo);
118 ASSERT_TRUE(ret != HDF_SUCCESS);
119 ret = instance->AddService(nullptr, &device, &servInfo);
120 ASSERT_TRUE(ret != HDF_SUCCESS);
121 ret = instance->UpdateService(instance, &device, &servInfo);
122 ASSERT_TRUE(ret != HDF_SUCCESS);
123 ret = instance->UpdateService(nullptr, &device, &servInfo);
124 ASSERT_TRUE(ret != HDF_SUCCESS);
125
126 struct DevSvcManagerProxy *proxy = reinterpret_cast<struct DevSvcManagerProxy *>(object);
127 struct HdfDeathRecipient recipient;
128 proxy->recipient.OnRemoteDied(&recipient, nullptr);
129 proxy->recipient.OnRemoteDied(nullptr, nullptr);
130 HdfRemoteServiceRecycle(proxy->remote);
131 proxy->remote = nullptr;
132 ret = instance->AddService(instance, &device, &servInfo);
133 ASSERT_TRUE(ret != HDF_SUCCESS);
134 ret = instance->UpdateService(instance, &device, &servInfo);
135 ASSERT_TRUE(ret != HDF_SUCCESS);
136 struct HdfObject *service = instance->GetService(instance, "test");
137 ASSERT_TRUE(service == nullptr);
138 instance->RemoveService(nullptr, "test", nullptr);
139 instance->RemoveService(instance, nullptr, nullptr);
140 instance->RemoveService(instance, "test", nullptr);
141 DevSvcManagerProxyRelease(object);
142 DevSvcManagerProxyRelease(nullptr);
143 }
144
145 HWTEST_F(DevHostTest, DevHostServiceTest, TestSize.Level1)
146 {
147 struct HdfObject *object = DevHostServiceCreate();
148 ASSERT_TRUE(object != nullptr);
149 struct IDevHostService *hostService = reinterpret_cast<struct IDevHostService *>(object);
150 struct DevHostService *devHost = reinterpret_cast<struct DevHostService *>(object);
151 devHost->hostName = "test_host";
152 ASSERT_TRUE(hostService->PmNotify != nullptr);
153 hostService->PmNotify(hostService, POWER_STATE_RESUME);
154 hostService->PmNotify(hostService, POWER_STATE_SUSPEND);
155 hostService->PmNotify(hostService, POWER_STATE_MAX);
156 hostService->PmNotify(nullptr, POWER_STATE_RESUME);
157 hostService->StartService(nullptr);
158 DevHostServiceRelease(object);
159 DevHostServiceRelease(nullptr);
160 DevHostServiceConstruct(nullptr);
161 DevHostServiceDestruct(nullptr);
162
163 hostService = DevHostServiceNewInstance(0, "sample_host");
164 ASSERT_TRUE(hostService != nullptr);
165 int32_t ret = DevHostServiceAddDevice(hostService, nullptr);
166 ASSERT_TRUE(ret != HDF_SUCCESS);
167 ret = DevHostServiceAddDevice(nullptr, nullptr);
168 ASSERT_TRUE(ret != HDF_SUCCESS);
169 ret = DevHostServiceDelDevice(hostService, 0);
170 ASSERT_TRUE(ret == HDF_SUCCESS);
171 ret = DevHostServiceDelDevice(nullptr, 0);
172 ASSERT_TRUE(ret == HDF_SUCCESS);
173
174 hostService = DevHostServiceNewInstance(0, nullptr);
175 ASSERT_TRUE(hostService != nullptr);
176 DevHostServiceFreeInstance(hostService);
177 DevHostServiceFreeInstance(nullptr);
178
179 struct DevmgrServiceClnt clnt;
180 clnt.devMgrSvcIf = nullptr;
181 DevmgrServiceClntFreeInstance(&clnt);
182 DevmgrServiceClntFreeInstance(nullptr);
183 }
184
HdfTestSuccBind(struct HdfDeviceObject * deviceObject)185 static int HdfTestSuccBind(struct HdfDeviceObject *deviceObject)
186 {
187 HDF_LOGI("HdfTestSuccBind enter!");
188 return HDF_SUCCESS;
189 }
190
HdfTestFailBind(struct HdfDeviceObject * deviceObject)191 static int HdfTestFailBind(struct HdfDeviceObject *deviceObject)
192 {
193 HDF_LOGI("HdfTestFailBind enter!");
194 return HDF_FAILURE;
195 }
196
HdfTestInit(struct HdfDeviceObject * deviceObject)197 static int HdfTestInit(struct HdfDeviceObject *deviceObject)
198 {
199 HDF_LOGI("HdfTestInit enter!");
200 return HDF_FAILURE;
201 }
202
203 HWTEST_F(DevHostTest, DevHostDeviceNodeTest1, TestSize.Level1)
204 {
205 struct HdfDriver driver;
206 struct HdfDriverEntry entry;
207 entry.Bind = nullptr;
208 driver.entry = &entry;
209 struct HdfDeviceInfo deviceInfo;
210 deviceInfo.permission = 0;
211 deviceInfo.deviceId = 0;
212 deviceInfo.policy = SERVICE_POLICY_NONE;
213 deviceInfo.svcName = "sample_service";
214 deviceInfo.deviceName = "sample_module";
215
216 struct HdfDeviceNode *devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
217 ASSERT_TRUE(devNode != nullptr);
218
219 devNode->servStatus = false;
220 int32_t ret = HdfDeviceNodeRemoveService(devNode);
221 ASSERT_TRUE(ret == HDF_SUCCESS);
222
223 ret = DeviceDriverBind(devNode);
224 ASSERT_TRUE(ret == HDF_SUCCESS);
225 HdfDeviceNodeFreeInstance(devNode);
226
227 entry.Bind = HdfTestSuccBind;
228 deviceInfo.policy = SERVICE_POLICY_PUBLIC;
229 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
230 ret = DeviceDriverBind(devNode);
231 ASSERT_TRUE(ret == HDF_SUCCESS);
232 HdfDeviceNodeFreeInstance(devNode);
233
234 entry.Bind = HdfTestFailBind;
235 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
236 ret = DeviceDriverBind(devNode);
237 ASSERT_TRUE(ret != HDF_SUCCESS);
238 HdfDeviceNodeFreeInstance(devNode);
239
240 entry.Bind = nullptr;
241 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
242 ret = DeviceDriverBind(devNode);
243 ASSERT_TRUE(ret != HDF_SUCCESS);
244 HdfDeviceNodeFreeInstance(devNode);
245
246 entry.Bind = nullptr;
247 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
248 devNode->policy = SERVICE_POLICY_CAPACITY;
249 ret = DeviceDriverBind(devNode);
250 ASSERT_TRUE(ret != HDF_SUCCESS);
251 HdfDeviceNodeFreeInstance(devNode);
252
253 deviceInfo.svcName = nullptr;
254 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
255 ASSERT_TRUE(devNode == nullptr);
256 devNode = HdfDeviceNodeNewInstance(nullptr, &driver);
257 ASSERT_TRUE(devNode == nullptr);
258 }
259
260 HWTEST_F(DevHostTest, DevHostDeviceNodeTest2, TestSize.Level1)
261 {
262 struct HdfDriverEntry entry;
263 struct HdfDriver driver;
264 driver.entry = &entry;
265
266 struct HdfDeviceInfo deviceInfo;
267 deviceInfo.deviceId = 0;
268 deviceInfo.permission = 0;
269 deviceInfo.svcName = "driver_service";
270 deviceInfo.deviceName = "driver_module";
271
272 deviceInfo.policy = SERVICE_POLICY_PUBLIC;
273 entry.Bind = HdfTestSuccBind;
274 entry.Init = HdfTestInit;
275 struct HdfDeviceNode *devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
276 ASSERT_TRUE(devNode != nullptr);
277 HdfDeviceNodeConstruct(devNode);
278 struct IDeviceNode *nodeIf = &devNode->super;
279 int32_t ret = nodeIf->LaunchNode(devNode);
280
281 entry.Bind = HdfTestFailBind;
282 entry.Init = HdfTestInit;
283 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
284 ASSERT_TRUE(devNode != nullptr);
285 HdfDeviceNodeConstruct(devNode);
286 nodeIf = &devNode->super;
287 ret = nodeIf->LaunchNode(devNode);
288
289 entry.Init = nullptr;
290 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
291 ASSERT_TRUE(devNode != nullptr);
292 HdfDeviceNodeConstruct(devNode);
293 nodeIf = &devNode->super;
294 ret = nodeIf->LaunchNode(devNode);
295 ASSERT_TRUE(ret != HDF_SUCCESS);
296
297 devNode->devStatus = DEVNODE_NONE;
298 nodeIf->UnlaunchNode(devNode);
299 }
300
301 HWTEST_F(DevHostTest, DevHostDeviceNodeTest3, TestSize.Level1)
302 {
303 struct HdfDriverEntry entry;
304 entry.Bind = nullptr;
305 struct HdfDriver driver;
306 driver.entry = &entry;
307
308 struct HdfDeviceInfo deviceInfo;
309 deviceInfo.permission = 0;
310 deviceInfo.deviceId = 0;
311 deviceInfo.svcName = "test_service";
312 deviceInfo.deviceName = "test_module";
313 struct HdfDeviceNode *devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
314 ASSERT_TRUE(devNode != nullptr);
315 struct IDeviceNode *nodeIf = &devNode->super;
316 int32_t ret = HdfDeviceNodeAddPowerStateListener(devNode, nullptr);
317 ASSERT_TRUE(ret == HDF_SUCCESS);
318 ret = HdfDeviceNodeAddPowerStateListener(devNode, nullptr);
319 ASSERT_TRUE(ret != HDF_SUCCESS);
320
321 HdfDeviceNodeRemovePowerStateListener(nullptr, nullptr);
322 HdfDeviceNodeRemovePowerStateListener(devNode, nullptr);
323 HdfDeviceNodeRemovePowerStateListener(devNode, nullptr);
324 devNode->deviceObject.service = nullptr;
325 ret = HdfDeviceNodePublishPublicService(devNode);
326 ASSERT_TRUE(ret != HDF_SUCCESS);
327 nodeIf->UnlaunchNode(nullptr);
328 HdfDeviceNodeFreeInstance(nullptr);
329 HdfDeviceNodeConstruct(nullptr);
330 HdfDeviceNodeDestruct(nullptr);
331 ret = HdfDeviceNodePublishPublicService(nullptr);
332 ASSERT_TRUE(ret != HDF_SUCCESS);
333 ret = HdfDeviceNodeRemoveService(nullptr);
334 ASSERT_TRUE(ret == HDF_SUCCESS);
335 ret = nodeIf->LaunchNode(nullptr);
336 ASSERT_TRUE(ret != HDF_SUCCESS);
337 ret = DeviceDriverBind(nullptr);
338 ASSERT_TRUE(ret != HDF_SUCCESS);
339 }
340
341 HWTEST_F(DevHostTest, DevHostDeviceTest, TestSize.Level1)
342 {
343 struct HdfObject *object = HdfDeviceCreate();
344 ASSERT_TRUE(object != nullptr);
345
346 struct IHdfDevice *device = reinterpret_cast<struct IHdfDevice *>(object);
347 int32_t ret = device->Attach(device, nullptr);
348 ASSERT_TRUE(ret != HDF_SUCCESS);
349 ret = device->Attach(nullptr, nullptr);
350 ASSERT_TRUE(ret != HDF_SUCCESS);
351
352 ret = device->DetachWithDevid(device, 0);
353 ASSERT_TRUE(ret != HDF_SUCCESS);
354
355 ret = HdfDeviceDetach(nullptr, nullptr);
356 ASSERT_TRUE(ret != HDF_SUCCESS);
357 ret = HdfDeviceDetach(device, nullptr);
358 ASSERT_TRUE(ret != HDF_SUCCESS);
359 HdfDeviceRelease(nullptr);
360 HdfDeviceFreeInstance(nullptr);
361 }
362
363 HWTEST_F(DevHostTest, DevHostDriverLoaderFullTest, TestSize.Level1)
364 {
365 struct HdfObject *object = HdfDriverLoaderFullCreate();
366 ASSERT_TRUE(object != nullptr);
367 struct HdfDriverLoader *loader = reinterpret_cast<struct HdfDriverLoader *>(object);
368 char testModule[PATH_MAX] = {0xa};
369 testModule[PATH_MAX - 1] = '0';
370 struct HdfDriver *driver = loader->super.GetDriver(nullptr);
371 ASSERT_TRUE(driver == nullptr);
372 driver = loader->super.GetDriver(testModule);
373 ASSERT_TRUE(driver == nullptr);
374 loader->super.ReclaimDriver(nullptr);
375 HdfDriverLoaderFullRelease(object);
376 HdfDriverLoaderFullRelease(nullptr);
377 }
378
379 HWTEST_F(DevHostTest, DevHostDeviceServiceStubTest, TestSize.Level1)
380 {
381 struct HdfObject *object = DeviceServiceStubCreate();
382 ASSERT_TRUE(object != nullptr);
383 struct IDeviceNode *deviceIf = reinterpret_cast<struct IDeviceNode *>(object);
384 struct DeviceServiceStub service;
385 struct HdfRemoteService remote;
386 struct HdfDeviceNode *devNode = reinterpret_cast<struct HdfDeviceNode *>(&service);
387 devNode->servName = nullptr;
388 int32_t ret = deviceIf->PublishService(devNode);
389 ASSERT_TRUE(ret != HDF_SUCCESS);
390 service.remote = &remote;
391 devNode->servName = HdfStringCopy("test");
392 ret = deviceIf->PublishService(devNode);
393 ASSERT_TRUE(ret != HDF_SUCCESS);
394
395 service.remote = nullptr;
396 devNode->policy = SERVICE_POLICY_NONE;
397 ret = deviceIf->PublishService(devNode);
398 ASSERT_TRUE(ret != HDF_SUCCESS);
399
400 devNode->policy = SERVICE_POLICY_PUBLIC;
401 devNode->deviceObject.deviceClass = DEVICE_CLASS_MAX;
402 devNode->interfaceDesc = nullptr;
403 ret = deviceIf->PublishService(devNode);
404 ASSERT_TRUE(ret != HDF_SUCCESS);
405
406 ret = deviceIf->RemoveService(nullptr);
407 ASSERT_TRUE(ret != HDF_SUCCESS);
408
409 OsalMemFree(devNode->servName);
410
411 DeviceServiceStubRelease(object);
412 DeviceServiceStubRelease(nullptr);
413
414 DevHostServiceStubRelease(nullptr);
415 }
416
DevHostTestDumpHostFunc(struct HdfSBuf * data,struct HdfSBuf * reply)417 static int32_t DevHostTestDumpHostFunc(struct HdfSBuf *data, struct HdfSBuf *reply)
418 {
419 uint32_t argv = 0;
420
421 (void)HdfSbufReadUint32(data, &argv);
422 HDF_LOGI("%{public}d", argv);
423
424 const char *value = HdfSbufReadString(data);
425 while (value != NULL && argv > 0) {
426 HDF_LOGI("%{public}s", value);
427 value = HdfSbufReadString(data);
428 argv--;
429 }
430
431 HdfSbufWriteString(reply, "test_host_dump\n");
432
433 return HDF_SUCCESS;
434 }
435
DevHostTestDumpServiceFunc(struct HdfSBuf * data,struct HdfSBuf * reply)436 static int32_t DevHostTestDumpServiceFunc(struct HdfSBuf *data, struct HdfSBuf *reply)
437 {
438 uint32_t argv = 0;
439 (void)HdfSbufReadUint32(data, &argv);
440 HDF_LOGI("%{public}d", argv);
441 const char *value = HdfSbufReadString(data);
442 while (value != NULL && argv > 0) {
443 HDF_LOGI("%{public}s", value);
444 value = HdfSbufReadString(data);
445 argv--;
446 }
447
448 HdfSbufWriteString(reply, "test_service_dump\n");
449
450 return HDF_SUCCESS;
451 }
452
453 HWTEST_F(DevHostTest, DevHostDumpTest001, TestSize.Level1)
454 {
455 DevHostDumpInit();
456 HdfSBuf * testSBufData = HdfSbufTypedObtain(SBUF_RAW);
457 HdfSBuf * testSBufReply = HdfSbufTypedObtain(SBUF_RAW);
458
459 // test DevHostDump NULL inpput
460 HDF_LOGI("test DevHostDump NULL inpput BEGIN");
461 DevHostDump(nullptr, nullptr);
462 ASSERT_TRUE(HdfSbufReadString(testSBufReply) == NULL);
463 DevHostDump(testSBufData, nullptr);
464 ASSERT_TRUE(HdfSbufReadString(testSBufReply) == NULL);
465 DevHostDump(nullptr, testSBufReply);
466 ASSERT_TRUE(HdfSbufReadString(testSBufReply) == NULL);
467 HDF_LOGI("test DevHostDump NULL inpput END");
468
469 // test DevHostDump null option
470 HDF_LOGI("test DevHostDump null option BEGIN");
471 DevHostDump(testSBufData, testSBufReply);
472 ASSERT_TRUE(HdfSbufReadString(testSBufReply) == NULL);
473 HDF_LOGI("test DevHostDump null option END");
474
475 // test DevHostDump invalid parameter brunch
476 HDF_LOGI("test DevHostDump invalid parameter brunch BEGIN");
477 HdfSbufWriteString(testSBufData, "dumpNothing");
478 DevHostDump(testSBufData, testSBufReply);
479 ASSERT_TRUE(HdfSbufReadString(testSBufReply) == NULL);
480 HDF_LOGI("test DevHostDump invalid parameter brunch END");
481
482 DevHostDumpDeInit();
483 }
484
485 HWTEST_F(DevHostTest, DevHostDumpTest002, TestSize.Level1)
486 {
487 DevHostDumpInit();
488 HdfSBuf * testSBufData = HdfSbufTypedObtain(SBUF_RAW);
489 HdfSBuf * testSBufReply = HdfSbufTypedObtain(SBUF_RAW);
490
491 // test DevHostDump option dumpHost without dumpHostFunc
492 HDF_LOGI("test DevHostDump option dumpHost without dumpHostFunc BEGIN");
493 HdfSbufFlush(testSBufData);
494 HdfSbufFlush(testSBufReply);
495 HdfSbufWriteString(testSBufData, "dumpHost");
496 DevHostDump(testSBufData, testSBufReply);
497 ASSERT_TRUE(strcmp(HdfSbufReadString(testSBufReply), "The host does not register dump function\n") == 0);
498 HdfSbufFlush(testSBufData);
499 HdfSbufFlush(testSBufReply);
500 HDF_LOGI("test DevHostDump option dumpHost without dumpHostFunc END");
501
502 // test DevHostRegisterDumpHost NULL input
503 HDF_LOGI("test DevHostRegisterDumpHost NULL input BEGIN");
504 int32_t ret = DevHostRegisterDumpHost(NULL);
505 ASSERT_TRUE(HDF_FAILURE == ret);
506 HDF_LOGI("test DevHostRegisterDumpHost NULL input END");
507
508 // test DevHostRegisterDumpHost normal brunch
509 HDF_LOGI("test DevHostRegisterDumpHost normal brunch BEGIN");
510 ret = DevHostRegisterDumpHost(DevHostTestDumpHostFunc);
511 ASSERT_TRUE(HDF_SUCCESS == ret);
512 HDF_LOGI("test DevHostRegisterDumpHost normal brunch END");
513
514 // test DevHostDump option dumpHost with dumpHostFunc
515 HDF_LOGI("test DevHostDump option dumpHost with dumpHostFunc BEGIN");
516 HdfSbufWriteString(testSBufData, "dumpHost");
517 DevHostDump(testSBufData, testSBufReply);
518 ASSERT_TRUE(strcmp(HdfSbufReadString(testSBufReply), "test_host_dump\n") == 0);
519 HdfSbufFlush(testSBufData);
520 HdfSbufFlush(testSBufReply);
521 HDF_LOGI("test DevHostDump option dumpHost with dumpHostFunc END");
522 }
523
524 HWTEST_F(DevHostTest, DevHostDumpServiceTest, TestSize.Level1)
525 {
526 HdfSBuf * testSBufData = HdfSbufTypedObtain(SBUF_RAW);
527 HdfSBuf * testSBufReply = HdfSbufTypedObtain(SBUF_RAW);
528 DevHostDumpInit();
529 // test DevHostRegisterDumpService NULL input
530 HDF_LOGI("test DevHostRegisterDumpService NULL input BEGIN");
531 int32_t ret = DevHostRegisterDumpService(nullptr, DevHostTestDumpServiceFunc);
532 ASSERT_TRUE(HDF_FAILURE == ret);
533 HDF_LOGI("test DevHostRegisterDumpService NULL input END");
534
535 // test DevHostRegisterDumpService with sample_driver_service
536 HDF_LOGI("test DevHostRegisterDumpService with sample_driver_service BEGIN");
537 ret = DevHostRegisterDumpService("sample_driver_service", DevHostTestDumpServiceFunc);
538 ASSERT_TRUE(HDF_SUCCESS == ret);
539 HDF_LOGI("test DevHostRegisterDumpService with sample_driver_service END");
540
541 // test DevHostRegisterDumpService with sample_driver_service Redundantly
542 HDF_LOGI("test DevHostRegisterDumpService with sample_driver_service Redundantly BEGIN");
543 ret = DevHostRegisterDumpService("sample_driver_service", DevHostTestDumpServiceFunc);
544 ASSERT_TRUE(HDF_FAILURE == ret);
545 HDF_LOGI("test DevHostRegisterDumpService with sample_driver_service Redundantly END");
546
547 // test DevDumpHost with option dumpService and wrong service name
548 HDF_LOGI("test DevDumpHost with option dumpService and wrong service name BEGIN");
549 HdfSbufWriteString(testSBufData, "dumpService");
550 HdfSbufWriteString(testSBufData, "no_driver_service");
551 DevHostDump(testSBufData, testSBufReply);
552 ASSERT_TRUE(strcmp(HdfSbufReadString(testSBufReply), "The service does not register dump function\n") == 0);
553 HdfSbufFlush(testSBufData);
554 HdfSbufFlush(testSBufReply);
555 HDF_LOGI("test DevDumpHost with option dumpService and wrong service name END");
556
557 // test DevDumpHost with option dumpService and correct service name
558 HDF_LOGI("test DevDumpHost with option dumpService and correct service name BEGIN");
559 HdfSbufWriteString(testSBufData, "dumpService");
560 HdfSbufWriteString(testSBufData, "sample_driver_service");
561 DevHostDump(testSBufData, testSBufReply);
562 ASSERT_TRUE(strcmp(HdfSbufReadString(testSBufReply), "test_service_dump\n") == 0);
563 HdfSbufFlush(testSBufData);
564 HdfSbufFlush(testSBufReply);
565 DevHostDumpDeInit();
566 HDF_LOGI("test DevDumpHost with option dumpService and correct service name END");
567 }
568 } // namespace OHOS
569