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