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 "device_service_stub.h"
22 #include "devmgr_service_clnt.h"
23 #include "devmgr_service_proxy.h"
24 #include "devsvc_manager_proxy.h"
25 #include "driver_loader_full.h"
26 #include "hdf_cstring.h"
27 #include "hdf_device.h"
28 #include "hdf_device_node.h"
29 #include "hdf_remote_service.h"
30 #include "hdf_log.h"
31 #include "osal_mem.h"
32
33 #define HDF_LOG_TAG host_test
34
35 namespace OHOS {
36 using namespace testing::ext;
37
38 class DevHostTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp();
43 void TearDown();
44 };
45
SetUpTestCase()46 void DevHostTest::SetUpTestCase()
47 {
48 }
49
TearDownTestCase()50 void DevHostTest::TearDownTestCase()
51 {
52 }
53
SetUp()54 void DevHostTest::SetUp()
55 {
56 }
57
TearDown()58 void DevHostTest::TearDown()
59 {
60 }
61
62 HWTEST_F(DevHostTest, DevHostDevMgrServiceProxyTest, TestSize.Level1)
63 {
64 struct HdfObject *object = DevmgrServiceProxyCreate();
65 ASSERT_TRUE(object != nullptr);
66 struct IDevmgrService *instance = reinterpret_cast<struct IDevmgrService *>(object);
67
68 int32_t ret = instance->AttachDeviceHost(instance, 0, nullptr);
69 ASSERT_TRUE(ret != HDF_SUCCESS);
70 ret = instance->AttachDevice(instance, nullptr);
71 ASSERT_TRUE(ret != HDF_SUCCESS);
72 ret = instance->LoadDevice(instance, nullptr);
73 ASSERT_TRUE(ret != HDF_SUCCESS);
74
75 struct DevmgrServiceProxy *proxy = reinterpret_cast<struct DevmgrServiceProxy *>(object);
76 HdfRemoteServiceRecycle(proxy->remote);
77 proxy->remote = nullptr;
78
79 ret = instance->AttachDeviceHost(instance, 0, nullptr);
80 ASSERT_TRUE(ret != HDF_SUCCESS);
81 ret = instance->AttachDevice(instance, nullptr);
82 ASSERT_TRUE(ret != HDF_SUCCESS);
83 ret = instance->AttachDevice(nullptr, nullptr);
84 ASSERT_TRUE(ret != HDF_SUCCESS);
85 ret = instance->DetachDevice(instance, 0);
86 ASSERT_TRUE(ret != HDF_SUCCESS);
87 ret = instance->DetachDevice(nullptr, 0);
88 ASSERT_TRUE(ret != HDF_SUCCESS);
89 ret = instance->LoadDevice(instance, nullptr);
90 ASSERT_TRUE(ret != HDF_SUCCESS);
91 ret = instance->LoadDevice(nullptr, nullptr);
92 ASSERT_TRUE(ret != HDF_SUCCESS);
93 DevmgrServiceProxyRelease(object);
94 DevmgrServiceProxyRelease(nullptr);
95 }
96
97 HWTEST_F(DevHostTest, DevHostDevSvcMgrProxyTest, TestSize.Level1)
98 {
99 struct HdfObject *object = DevSvcManagerProxyCreate();
100 ASSERT_TRUE(object != nullptr);
101 struct IDevSvcManager *instance = reinterpret_cast<struct IDevSvcManager *>(object);
102 struct HdfDeviceObject device;
103 struct HdfServiceInfo servInfo;
104 servInfo.servName = "test";
105 servInfo.devClass = DEVICE_CLASS_MAX;
106 int32_t ret = instance->AddService(instance, &device, &servInfo);
107 ASSERT_TRUE(ret != HDF_SUCCESS);
108 ret = instance->AddService(instance, nullptr, &servInfo);
109 ASSERT_TRUE(ret != HDF_SUCCESS);
110 ret = instance->UpdateService(instance, &device, &servInfo);
111 ASSERT_TRUE(ret != HDF_SUCCESS);
112
113 servInfo.servName = nullptr;
114 ret = instance->AddService(instance, &device, &servInfo);
115 ASSERT_TRUE(ret != HDF_SUCCESS);
116 ret = instance->AddService(nullptr, &device, &servInfo);
117 ASSERT_TRUE(ret != HDF_SUCCESS);
118 ret = instance->UpdateService(instance, &device, &servInfo);
119 ASSERT_TRUE(ret != HDF_SUCCESS);
120 ret = instance->UpdateService(nullptr, &device, &servInfo);
121 ASSERT_TRUE(ret != HDF_SUCCESS);
122
123 struct DevSvcManagerProxy *proxy = reinterpret_cast<struct DevSvcManagerProxy *>(object);
124 struct HdfDeathRecipient recipient;
125 proxy->recipient.OnRemoteDied(&recipient, nullptr);
126 proxy->recipient.OnRemoteDied(nullptr, nullptr);
127 HdfRemoteServiceRecycle(proxy->remote);
128 proxy->remote = nullptr;
129 ret = instance->AddService(instance, &device, &servInfo);
130 ASSERT_TRUE(ret != HDF_SUCCESS);
131 ret = instance->UpdateService(instance, &device, &servInfo);
132 ASSERT_TRUE(ret != HDF_SUCCESS);
133 struct HdfObject *service = instance->GetService(instance, "test");
134 ASSERT_TRUE(service == nullptr);
135 instance->RemoveService(nullptr, "test", nullptr);
136 instance->RemoveService(instance, nullptr, nullptr);
137 instance->RemoveService(instance, "test", nullptr);
138 DevSvcManagerProxyRelease(object);
139 DevSvcManagerProxyRelease(nullptr);
140 }
141
142 HWTEST_F(DevHostTest, DevHostServiceTest, TestSize.Level1)
143 {
144 struct HdfObject *object = DevHostServiceCreate();
145 ASSERT_TRUE(object != nullptr);
146 struct IDevHostService *hostService = reinterpret_cast<struct IDevHostService *>(object);
147 struct DevHostService *devHost = reinterpret_cast<struct DevHostService *>(object);
148 devHost->hostName = "test_host";
149 ASSERT_TRUE(hostService->PmNotify != nullptr);
150 hostService->PmNotify(hostService, POWER_STATE_RESUME);
151 hostService->PmNotify(hostService, POWER_STATE_SUSPEND);
152 hostService->PmNotify(hostService, POWER_STATE_MAX);
153 hostService->PmNotify(nullptr, POWER_STATE_RESUME);
154 hostService->StartService(nullptr);
155 DevHostServiceRelease(object);
156 DevHostServiceRelease(nullptr);
157 DevHostServiceConstruct(nullptr);
158 DevHostServiceDestruct(nullptr);
159
160 hostService = DevHostServiceNewInstance(0, "sample_host");
161 ASSERT_TRUE(hostService != nullptr);
162 int32_t ret = DevHostServiceAddDevice(hostService, nullptr);
163 ASSERT_TRUE(ret != HDF_SUCCESS);
164 ret = DevHostServiceAddDevice(nullptr, nullptr);
165 ASSERT_TRUE(ret != HDF_SUCCESS);
166 ret = DevHostServiceDelDevice(hostService, 0);
167 ASSERT_TRUE(ret == HDF_SUCCESS);
168 ret = DevHostServiceDelDevice(nullptr, 0);
169 ASSERT_TRUE(ret == HDF_SUCCESS);
170
171 hostService = DevHostServiceNewInstance(0, nullptr);
172 ASSERT_TRUE(hostService != nullptr);
173 DevHostServiceFreeInstance(hostService);
174 DevHostServiceFreeInstance(nullptr);
175
176 struct DevmgrServiceClnt clnt;
177 clnt.devMgrSvcIf = nullptr;
178 DevmgrServiceClntFreeInstance(&clnt);
179 DevmgrServiceClntFreeInstance(nullptr);
180 }
181
HdfTestSuccBind(struct HdfDeviceObject * deviceObject)182 static int HdfTestSuccBind(struct HdfDeviceObject *deviceObject)
183 {
184 HDF_LOGI("HdfTestSuccBind enter!");
185 return HDF_SUCCESS;
186 }
187
HdfTestFailBind(struct HdfDeviceObject * deviceObject)188 static int HdfTestFailBind(struct HdfDeviceObject *deviceObject)
189 {
190 HDF_LOGI("HdfTestFailBind enter!");
191 return HDF_FAILURE;
192 }
193
HdfTestInit(struct HdfDeviceObject * deviceObject)194 static int HdfTestInit(struct HdfDeviceObject *deviceObject)
195 {
196 HDF_LOGI("HdfTestInit enter!");
197 return HDF_FAILURE;
198 }
199
200 HWTEST_F(DevHostTest, DevHostDeviceNodeTest1, TestSize.Level1)
201 {
202 struct HdfDriver driver;
203 struct HdfDriverEntry entry;
204 entry.Bind = nullptr;
205 driver.entry = &entry;
206 struct HdfDeviceInfo deviceInfo;
207 deviceInfo.permission = 0;
208 deviceInfo.deviceId = 0;
209 deviceInfo.policy = SERVICE_POLICY_NONE;
210 deviceInfo.svcName = "sample_service";
211 deviceInfo.deviceName = "sample_module";
212
213 struct HdfDeviceNode *devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
214 ASSERT_TRUE(devNode != nullptr);
215
216 devNode->servStatus = false;
217 int32_t ret = HdfDeviceNodeRemoveService(devNode);
218 ASSERT_TRUE(ret == HDF_SUCCESS);
219
220 ret = DeviceDriverBind(devNode);
221 ASSERT_TRUE(ret == HDF_SUCCESS);
222 HdfDeviceNodeFreeInstance(devNode);
223
224 entry.Bind = HdfTestSuccBind;
225 deviceInfo.policy = SERVICE_POLICY_PUBLIC;
226 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
227 ret = DeviceDriverBind(devNode);
228 ASSERT_TRUE(ret == HDF_SUCCESS);
229 HdfDeviceNodeFreeInstance(devNode);
230
231 entry.Bind = HdfTestFailBind;
232 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
233 ret = DeviceDriverBind(devNode);
234 ASSERT_TRUE(ret != HDF_SUCCESS);
235 HdfDeviceNodeFreeInstance(devNode);
236
237 entry.Bind = nullptr;
238 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
239 ret = DeviceDriverBind(devNode);
240 ASSERT_TRUE(ret != HDF_SUCCESS);
241 HdfDeviceNodeFreeInstance(devNode);
242
243 entry.Bind = nullptr;
244 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
245 devNode->policy = SERVICE_POLICY_CAPACITY;
246 ret = DeviceDriverBind(devNode);
247 ASSERT_TRUE(ret != HDF_SUCCESS);
248 HdfDeviceNodeFreeInstance(devNode);
249
250 deviceInfo.svcName = nullptr;
251 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
252 ASSERT_TRUE(devNode == nullptr);
253 devNode = HdfDeviceNodeNewInstance(nullptr, &driver);
254 ASSERT_TRUE(devNode == nullptr);
255 }
256
257 HWTEST_F(DevHostTest, DevHostDeviceNodeTest2, TestSize.Level1)
258 {
259 struct HdfDriverEntry entry;
260 struct HdfDriver driver;
261 driver.entry = &entry;
262
263 struct HdfDeviceInfo deviceInfo;
264 deviceInfo.deviceId = 0;
265 deviceInfo.permission = 0;
266 deviceInfo.svcName = "driver_service";
267 deviceInfo.deviceName = "driver_module";
268
269 deviceInfo.policy = SERVICE_POLICY_PUBLIC;
270 entry.Bind = HdfTestSuccBind;
271 entry.Init = HdfTestInit;
272 struct HdfDeviceNode *devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
273 ASSERT_TRUE(devNode != nullptr);
274 HdfDeviceNodeConstruct(devNode);
275 struct IDeviceNode *nodeIf = &devNode->super;
276 int32_t ret = nodeIf->LaunchNode(devNode);
277
278 entry.Bind = HdfTestFailBind;
279 entry.Init = HdfTestInit;
280 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
281 ASSERT_TRUE(devNode != nullptr);
282 HdfDeviceNodeConstruct(devNode);
283 nodeIf = &devNode->super;
284 ret = nodeIf->LaunchNode(devNode);
285
286 entry.Init = nullptr;
287 devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
288 ASSERT_TRUE(devNode != nullptr);
289 HdfDeviceNodeConstruct(devNode);
290 nodeIf = &devNode->super;
291 ret = nodeIf->LaunchNode(devNode);
292 ASSERT_TRUE(ret != HDF_SUCCESS);
293
294 devNode->devStatus = DEVNODE_NONE;
295 nodeIf->UnlaunchNode(devNode);
296 }
297
298 HWTEST_F(DevHostTest, DevHostDeviceNodeTest3, TestSize.Level1)
299 {
300 struct HdfDriverEntry entry;
301 entry.Bind = nullptr;
302 struct HdfDriver driver;
303 driver.entry = &entry;
304
305 struct HdfDeviceInfo deviceInfo;
306 deviceInfo.permission = 0;
307 deviceInfo.deviceId = 0;
308 deviceInfo.svcName = "test_service";
309 deviceInfo.deviceName = "test_module";
310 struct HdfDeviceNode *devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
311 ASSERT_TRUE(devNode != nullptr);
312 struct IDeviceNode *nodeIf = &devNode->super;
313 int32_t ret = HdfDeviceNodeAddPowerStateListener(devNode, nullptr);
314 ASSERT_TRUE(ret == HDF_SUCCESS);
315 ret = HdfDeviceNodeAddPowerStateListener(devNode, nullptr);
316 ASSERT_TRUE(ret != HDF_SUCCESS);
317
318 HdfDeviceNodeRemovePowerStateListener(nullptr, nullptr);
319 HdfDeviceNodeRemovePowerStateListener(devNode, nullptr);
320 HdfDeviceNodeRemovePowerStateListener(devNode, nullptr);
321 devNode->deviceObject.service = nullptr;
322 ret = HdfDeviceNodePublishPublicService(devNode);
323 ASSERT_TRUE(ret != HDF_SUCCESS);
324 nodeIf->UnlaunchNode(nullptr);
325 HdfDeviceNodeFreeInstance(nullptr);
326 HdfDeviceNodeConstruct(nullptr);
327 HdfDeviceNodeDestruct(nullptr);
328 ret = HdfDeviceNodePublishPublicService(nullptr);
329 ASSERT_TRUE(ret != HDF_SUCCESS);
330 ret = HdfDeviceNodeRemoveService(nullptr);
331 ASSERT_TRUE(ret == HDF_SUCCESS);
332 ret = nodeIf->LaunchNode(nullptr);
333 ASSERT_TRUE(ret != HDF_SUCCESS);
334 ret = DeviceDriverBind(nullptr);
335 ASSERT_TRUE(ret != HDF_SUCCESS);
336 }
337
338 HWTEST_F(DevHostTest, DevHostDeviceTest, TestSize.Level1)
339 {
340 struct HdfObject *object = HdfDeviceCreate();
341 ASSERT_TRUE(object != nullptr);
342
343 struct IHdfDevice *device = reinterpret_cast<struct IHdfDevice *>(object);
344 int32_t ret = device->Attach(device, nullptr);
345 ASSERT_TRUE(ret != HDF_SUCCESS);
346 ret = device->Attach(nullptr, nullptr);
347 ASSERT_TRUE(ret != HDF_SUCCESS);
348
349 ret = device->DetachWithDevid(device, 0);
350 ASSERT_TRUE(ret != HDF_SUCCESS);
351
352 ret = HdfDeviceDetach(nullptr, nullptr);
353 ASSERT_TRUE(ret != HDF_SUCCESS);
354 ret = HdfDeviceDetach(device, nullptr);
355 ASSERT_TRUE(ret != HDF_SUCCESS);
356 HdfDeviceRelease(nullptr);
357 HdfDeviceFreeInstance(nullptr);
358 }
359
360 HWTEST_F(DevHostTest, DevHostDriverLoaderFullTest, TestSize.Level1)
361 {
362 struct HdfObject *object = HdfDriverLoaderFullCreate();
363 ASSERT_TRUE(object != nullptr);
364 struct HdfDriverLoader *loader = reinterpret_cast<struct HdfDriverLoader *>(object);
365 char testModule[PATH_MAX] = {0xa};
366 testModule[PATH_MAX - 1] = '0';
367 struct HdfDriver *driver = loader->super.GetDriver(nullptr);
368 ASSERT_TRUE(driver == nullptr);
369 driver = loader->super.GetDriver(testModule);
370 ASSERT_TRUE(driver == nullptr);
371 loader->super.ReclaimDriver(nullptr);
372 HdfDriverLoaderFullRelease(object);
373 HdfDriverLoaderFullRelease(nullptr);
374 }
375
376 HWTEST_F(DevHostTest, DevHostDeviceServiceStubTest, TestSize.Level1)
377 {
378 struct HdfObject *object = DeviceServiceStubCreate();
379 ASSERT_TRUE(object != nullptr);
380 struct IDeviceNode *deviceIf = reinterpret_cast<struct IDeviceNode *>(object);
381 struct DeviceServiceStub service;
382 struct HdfRemoteService remote;
383 struct HdfDeviceNode *devNode = reinterpret_cast<struct HdfDeviceNode *>(&service);
384 devNode->servName = nullptr;
385 int32_t ret = deviceIf->PublishService(devNode);
386 ASSERT_TRUE(ret != HDF_SUCCESS);
387 service.remote = &remote;
388 devNode->servName = HdfStringCopy("test");
389 ret = deviceIf->PublishService(devNode);
390 ASSERT_TRUE(ret != HDF_SUCCESS);
391
392 service.remote = nullptr;
393 devNode->policy = SERVICE_POLICY_NONE;
394 ret = deviceIf->PublishService(devNode);
395 ASSERT_TRUE(ret != HDF_SUCCESS);
396
397 devNode->policy = SERVICE_POLICY_PUBLIC;
398 devNode->deviceObject.deviceClass = DEVICE_CLASS_MAX;
399 devNode->interfaceDesc = nullptr;
400 ret = deviceIf->PublishService(devNode);
401 ASSERT_TRUE(ret != HDF_SUCCESS);
402
403 ret = deviceIf->RemoveService(nullptr);
404 ASSERT_TRUE(ret != HDF_SUCCESS);
405
406 OsalMemFree(devNode->servName);
407
408 DeviceServiceStubRelease(object);
409 DeviceServiceStubRelease(nullptr);
410
411 DevHostServiceStubRelease(nullptr);
412 }
413 } // namespace OHOS
414