1 /*
2 * Copyright (c) 2020 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 "utest_input_manager_impl.h"
17 #include <osal_mem.h>
18 #include "input_proxy.h"
19 #include "input_host_callback.h"
20
21 const int32_t INIT_DEFAULT_VALUE = (255);
22 const int32_t GET_EVENT_TRY_NUM = (20);
23 const int32_t PREPARE_TIME_MS = (5000);
24 const int32_t ONE_PERIOD_TIME_MS = (500);
25 const int32_t KEEP_ALIVE_TIME_S = (100);
26 const int32_t TOUCH_INDEX = (1);
27 const int32_t DEV_INDEX2 = (2);
28 const int32_t DEV_INDEX3 = (3);
29 const int32_t INVALID_INDEX = (15);
30 const int32_t NAME_MAX_LEN = (10);
31 const int32_t TEST_RESULT_LEN = (32);
32 const int32_t MAX_DEVICES = 32;
33 using namespace OHOS;
34 using namespace testing::ext;
35 using namespace OHOS::Input;
SetUpTestCase(void)36 void InputManagerImplTetst::SetUpTestCase(void)
37 {
38 std::cout << "Input::InputManagerImplTetst SetUpTestCase start" << std::endl;
39 }
40
TearDownTestCase(void)41 void InputManagerImplTetst::TearDownTestCase(void)
42 {
43 std::cout << "Input::InputManagerImplTetst TearDownTestCase" << std::endl;
44 }
45
SetUp(void)46 void InputManagerImplTetst::SetUp(void)
47 {
48 }
49
TearDown(void)50 void InputManagerImplTetst::TearDown(void)
51 {
52 }
53
54 HWTEST_F(InputManagerImplTetst, UTestScanInputDevice, TestSize.Level0)
55 {
56 DevDesc sta[MAX_DEVICES] = {};
57 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
58 ASSERT_TRUE(InputHostObj != nullptr);
59 auto arrLen = sizeof(sta)/sizeof(DevDesc);
60 auto rc = InputHostObj->ScanInputDevice(sta, arrLen);
61 for (auto i=0; i< arrLen ; i++) {
62 std::cout<<"Index: "<<sta[i].devIndex << "Type: " << sta[i].devType << std::endl;
63 }
64 EXPECT_EQ(INPUT_SUCCESS, rc);
65 }
66
67 HWTEST_F(InputManagerImplTetst, UTestScanInputDeviceFailed, TestSize.Level0)
68 {
69 DevDesc sta[MAX_DEVICES] = {};
70 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_serviceaaa");
71 EXPECT_EQ(InputHostObj, nullptr);
72 }
73
74
75 HWTEST_F(InputManagerImplTetst, UTestOpenInputDevice, TestSize.Level0)
76 {
77 std::cout << "Input::InputManagerImplTetst::" << __func__ << std::endl;
78 uint32_t index = TOUCH_INDEX;
79 std::cout << "UTestOpenInputDevice" << __func__ << __LINE__ << __FILE__ << std::endl;
80 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
81 ASSERT_TRUE(InputHostObj != nullptr);
82 EXPECT_EQ(INPUT_SUCCESS, InputHostObj->OpenInputDevice(index));
83 std::cout << "UTestOpenInputDevice" << __func__ << __LINE__ << __FILE__ << std::endl;
84 }
85
86 HWTEST_F(InputManagerImplTetst, UTestOpenInputDeviceFailed, TestSize.Level0)
87 {
88 std::cout << "Input::InputManagerImplTetst::" << __func__ << std::endl;
89 uint32_t index = INVALID_INDEX;
90 std::cout << "UTestOpenInputDevice" << __func__ << __LINE__ << __FILE__ << std::endl;
91 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
92 ASSERT_TRUE(InputHostObj != nullptr);
93 EXPECT_NE(INPUT_SUCCESS, InputHostObj->OpenInputDevice(index));
94 std::cout << "UTestOpenInputDevice" << __func__ << __LINE__ << __FILE__ << std::endl;
95 }
96
97 HWTEST_F(InputManagerImplTetst, UTestCloseInputDevice, TestSize.Level0)
98 {
99 std::cout << "Input::InputManagerImplTetst::" << __func__ << std::endl;
100 uint32_t index = TOUCH_INDEX;
101 std::cout << "UTestCloseInputDevice" << __func__ << __LINE__ << __FILE__ << std::endl;
102 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
103 ASSERT_TRUE(InputHostObj != nullptr);
104 EXPECT_EQ(INPUT_SUCCESS, InputHostObj->CloseInputDevice(index));
105 std::cout << "UTestCloseInputDevice" << __func__ << __LINE__ << __FILE__ << std::endl;
106 }
107
108 HWTEST_F(InputManagerImplTetst, UTestCloseInputDeviceFailed, TestSize.Level0)
109 {
110 std::cout << "Input::InputManagerImplTetst::" << __func__ << std::endl;
111 uint32_t index = INVALID_INDEX;
112 std::cout << "UTestCloseInputDevice" << __func__ << __LINE__ << __FILE__ << std::endl;
113 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
114 ASSERT_TRUE(InputHostObj != nullptr);
115 EXPECT_NE(INPUT_SUCCESS, InputHostObj->CloseInputDevice(index));
116 std::cout << "UTestCloseInputDevice" << __func__ << __LINE__ << __FILE__ << std::endl;
117 }
118
119
120 HWTEST_F(InputManagerImplTetst, UTestGetGetInputDevice, TestSize.Level0)
121 {
122 std::cout << "Input::InputManagerImplTetst::" << __func__ << std::endl;
123 HDF_LOGI("%{public}s: [Input] UTestGetGetInputDevice enter", __func__);
124 DeviceInfo *dev = new DeviceInfo();
125 uint32_t devIndex = TOUCH_INDEX;
126 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
127 ASSERT_TRUE(InputHostObj != nullptr);
128 auto ret = InputHostObj->GetInputDevice(devIndex, &dev);
129 if (ret) {
130 HDF_LOGE("%{public}s: get device1 failed, ret %{public}d", __func__, ret);
131 }
132 HDF_LOGI("####$%{public}s: devindex = %{public}u, devType = %{public}u",
133 __func__, dev->devIndex, dev->devType);
134 HDF_LOGI("#####%{public}s: chipInfo = %{public}s, vendorName = %{public}s, chipName = %{public}s",
135 __func__, dev->chipInfo, dev->vendorName, dev->chipName);
136 EXPECT_EQ(ret, INPUT_SUCCESS);
137 }
138
139 HWTEST_F(InputManagerImplTetst, UTestGetGetInputDeviceFailed, TestSize.Level0)
140 {
141 std::cout << "Input::InputManagerImplTetst::" << __func__ << std::endl;
142 HDF_LOGI("%{public}s: [Input] UTestGetGetInputDevice enter", __func__);
143 DeviceInfo *dev = new DeviceInfo();
144 uint32_t devIndex = INVALID_INDEX;
145 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
146 ASSERT_TRUE(InputHostObj != nullptr);
147 auto ret = InputHostObj->GetInputDevice(devIndex, &dev);
148 if (ret) {
149 HDF_LOGE("%{public}s: get device1 failed, ret %{public}d", __func__, ret);
150 }
151 HDF_LOGI("####$%{public}s: devindex = %{public}u, devType = %{public}u",
152 __func__, dev->devIndex, dev->devType);
153 HDF_LOGI("#####%{public}s: chipInfo = %{public}s, vendorName = %{public}s, chipName = %{public}s",
154 __func__, dev->chipInfo, dev->vendorName, dev->chipName);
155 EXPECT_NE(ret, INPUT_SUCCESS);
156 }
157
158 HWTEST_F(InputManagerImplTetst, UTestGetGetInputDeviceList, TestSize.Level0)
159 {
160 HDF_LOGI("%{public}s: [Input] UTestGetGetInputDevice enter", __func__);
161 uint32_t devNum = 0;
162 DeviceInfo* dev = (DeviceInfo*)(new char[ sizeof(DeviceInfo) * TEST_RESULT_LEN]);
163 uint32_t size = TEST_RESULT_LEN;
164 int32_t rc = 0;
165 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
166 ASSERT_TRUE(InputHostObj != nullptr);
167 rc = InputHostObj->GetInputDeviceList(&devNum, &dev, size);
168
169 HDF_LOGI("#####%{public}s: num = %{public}u, size[%{public}d]'s info is:[%{public}p]",
170 __func__, devNum, size, dev);
171
172 for (uint32_t i = 0; i < devNum; i++) {
173 if (dev != nullptr && (dev+i) != nullptr) {
174 HDF_LOGI("####%{public}s: index = %{public}d, devType = %{public}d",
175 __func__, (dev+i)->devIndex, (dev+i)->devType);
176 HDF_LOGI("####%{public}s: chipInfo = %{public}s, vendorName = %{public}s, chipName = %{public}s",
177 __func__, (dev+i)->chipInfo, (dev+i)->vendorName, (dev+i)->chipName);
178 }
179 }
180 EXPECT_EQ(INPUT_SUCCESS, rc);
181 }
182
183 HWTEST_F(InputManagerImplTetst, UTestGetGetInputDeviceListFailed, TestSize.Level0)
184 {
185 HDF_LOGI("%{public}s: [Input] UTestGetGetInputDevice enter", __func__);
186 uint32_t devNum = 0;
187 DeviceInfo* dev = nullptr;
188 uint32_t size = TEST_RESULT_LEN;
189 int32_t rc = 0;
190 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
191 ASSERT_TRUE(InputHostObj != nullptr);
192 rc = InputHostObj->GetInputDeviceList(&devNum, &dev, size);
193 EXPECT_NE(INPUT_SUCCESS, rc);
194 }
195
196
197 HWTEST_F(InputManagerImplTetst, GetVendorName001, TestSize.Level0)
198 {
199 HDF_LOGI("%{public}s: [Input] GetVendorName001 enter", __func__);
200 int32_t ret;
201 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
202 ASSERT_TRUE(InputHostObj != nullptr);
203 char* vendorName = new char[MAX_NODE_PATH_LEN];
204 for (auto i=1; i<4; i++) {
205 ret = InputHostObj->GetVendorName(i, vendorName, MAX_NODE_PATH_LEN);
206 if (ret) {
207 HDF_LOGE("%{public}s: get device1's vendor name failed, ret %{public}d", __func__, ret);
208 }
209 HDF_LOGI("#####%{public}s: device1's vendor name is: %{public}s", __func__, vendorName);
210 }
211 EXPECT_EQ(ret, INPUT_SUCCESS);
212 }
213
214
215 HWTEST_F(InputManagerImplTetst, GetChipInfo, TestSize.Level0)
216 {
217 HDF_LOGI("%{public}s: [Input] GetChipInfo enter", __func__);
218 int32_t ret;
219 uint32_t devIndex = TOUCH_INDEX;
220 uint32_t length = MAX_NODE_PATH_LEN;
221 char* chipInfo = new char[MAX_NODE_PATH_LEN];
222 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
223 ASSERT_TRUE(InputHostObj != nullptr);
224 ret = InputHostObj->GetChipInfo(devIndex, chipInfo, length);
225 if (ret) {
226 HDF_LOGE("%{public}s: get device1's chipInfo failed, ret %{public}d", __func__, ret);
227 }
228 HDF_LOGI("#####%{public}s: device1's chipInfo is %{public}s:", __func__, chipInfo);
229 EXPECT_EQ(ret, INPUT_SUCCESS);
230 }
231
232 HWTEST_F(InputManagerImplTetst, GetChipInfoFailed, TestSize.Level0)
233 {
234 HDF_LOGI("%{public}s: [Input] GetChipInfo enter", __func__);
235 int32_t ret;
236 uint32_t devIndex = INVALID_INDEX;
237 uint32_t length = MAX_NODE_PATH_LEN;
238 char* chipInfo = new char[MAX_NODE_PATH_LEN];
239 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
240 ASSERT_TRUE(InputHostObj != nullptr);
241 ret = InputHostObj->GetChipInfo(devIndex, chipInfo, length);
242 if (ret) {
243 HDF_LOGE("%{public}s: get device1's chipInfo failed, ret %{public}d", __func__, ret);
244 }
245 HDF_LOGI("#####%{public}s: device1's chipInfo is %{public}s:", __func__, chipInfo);
246 EXPECT_EQ(ret, INPUT_SUCCESS);
247 }
248
249 HWTEST_F(InputManagerImplTetst, GetChipName, TestSize.Level0)
250 {
251 HDF_LOGI("%{public}s: [Input] GetChipName enter", __func__);
252 int32_t ret;
253 uint32_t devIndex = TOUCH_INDEX;
254 uint32_t length = MAX_NODE_PATH_LEN;
255 char* chipName = new char[MAX_NODE_PATH_LEN];
256 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
257 ASSERT_TRUE(InputHostObj != nullptr);
258 ret = InputHostObj->GetChipName(devIndex, chipName, length);
259 if (ret) {
260 HDF_LOGE("%{public}s: get device1's vendor name failed, ret %{public}d", __func__, ret);
261 }
262 HDF_LOGI("#####%{public}s: device1's chipName is %{public}s:", __func__, chipName);
263 EXPECT_EQ(ret, INPUT_SUCCESS);
264 }
265
266 HWTEST_F(InputManagerImplTetst, GetChipNameFailed, TestSize.Level0)
267 {
268 HDF_LOGI("%{public}s: [Input] GetChipName enter", __func__);
269 int32_t ret;
270 uint32_t devIndex = INVALID_INDEX;
271 uint32_t length = MAX_NODE_PATH_LEN;
272 char* chipName = new char[MAX_NODE_PATH_LEN];
273 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
274 ASSERT_TRUE(InputHostObj != nullptr);
275 ret = InputHostObj->GetChipName(devIndex, chipName, length);
276 if (ret) {
277 HDF_LOGE("%{public}s: get device1's vendor name failed, ret %{public}d", __func__, ret);
278 }
279 HDF_LOGI("#####%{public}s: device1's chipName is %{public}s:", __func__, chipName);
280 EXPECT_EQ(ret, INPUT_SUCCESS);
281 }
282
283 HWTEST_F(InputManagerImplTetst, RegisterReportCallback, TestSize.Level0)
284 {
285 HDF_LOGI("%{public}s: [Input] RegisterReportCallback enter", __func__);
286 int32_t ret;
287 uint32_t devIndex = TOUCH_INDEX;
288 static OHOS::sptr<InputReportEventCallback> callback = new InputReportEventCallback();
289 static OHOS::sptr<InputHostReportEventCallback> callback1 = new InputHostReportEventCallback();
290 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
291 ASSERT_TRUE(InputHostObj != nullptr);
292 ret = InputHostObj->RegisterReportCallback(devIndex, callback);
293 if (ret) {
294 HDF_LOGE("%{public}s:RegisterHotPlugCallback failed, ret %{public}d", __func__, ret);
295 }
296 ret = InputHostObj->RegisterReportCallback(DEV_INDEX2, callback);
297 if (ret) {
298 HDF_LOGE("%{public}s:RegisterHotPlugCallback failed, ret %{public}d", __func__, ret);
299 }
300 ret = InputHostObj->RegisterReportCallback(DEV_INDEX3, callback);
301 if (ret) {
302 HDF_LOGE("%{public}s:RegisterHotPlugCallback failed, ret %{public}d", __func__, ret);
303 }
304 EXPECT_EQ(ret, INPUT_SUCCESS);
305 ret = InputHostObj->RegisterHotPlugCallback(callback1);
306 if (ret) {
307 HDF_LOGE("%{public}s: RegisterReportCallback failed, ret %{public}d", __func__, ret);
308 }
309 HDF_LOGI("#####%{public}s: %{public}d:", __func__, __LINE__);
310 EXPECT_EQ(ret, INPUT_SUCCESS);
311 EXPECT_EQ(INPUT_SUCCESS, InputHostObj->OpenInputDevice(devIndex));
312 EXPECT_EQ(INPUT_SUCCESS, InputHostObj->OpenInputDevice(DEV_INDEX2));
313 EXPECT_EQ(INPUT_SUCCESS, InputHostObj->OpenInputDevice(DEV_INDEX3));
314 sleep(KEEP_ALIVE_TIME_S);
315 }
316
317 HWTEST_F(InputManagerImplTetst, UnregisterReportCallback, TestSize.Level0)
318 {
319 HDF_LOGI("%{public}s: [Input] UnregisterReportCallback enter", __func__);
320 int32_t ret;
321 uint32_t devIndex = TOUCH_INDEX;
322 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
323 ASSERT_TRUE(InputHostObj != nullptr);
324 ret = InputHostObj->UnregisterReportCallback(devIndex);
325 if (ret) {
326 HDF_LOGE("%{public}s: get device1's vendor name failed, ret %{public}d", __func__, ret);
327 }
328 HDF_LOGI("#####%{public}s: %{public}d:", __func__, __LINE__);
329 EXPECT_EQ(ret, INPUT_SUCCESS);
330 }
331
332 HWTEST_F(InputManagerImplTetst, UnregisterReportCallback1, TestSize.Level0)
333 {
334 HDF_LOGI("%{public}s: [Input] UnregisterReportCallback enter", __func__);
335 int32_t ret;
336 uint32_t devIndex = INVALID_INDEX;
337 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
338 ASSERT_TRUE(InputHostObj != nullptr);
339 ret = InputHostObj->UnregisterReportCallback(devIndex);
340 if (ret) {
341 HDF_LOGE("%{public}s: get device1's vendor name failed, ret %{public}d", __func__, ret);
342 }
343 HDF_LOGI("#####%{public}s: %{public}d:", __func__, __LINE__);
344 EXPECT_EQ(ret, INPUT_SUCCESS);
345 }
346
347 HWTEST_F(InputManagerImplTetst, RegisterHotPlugCallback, TestSize.Level0)
348 {
349 int32_t ret;
350 static OHOS::sptr<InputHostReportEventCallback> callback1 = new InputHostReportEventCallback();
351 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
352 ASSERT_TRUE(InputHostObj != nullptr);
353 ret = InputHostObj->RegisterHotPlugCallback(callback1);
354 if (ret) {
355 HDF_LOGE("%{public}s:RegisterHotPlugCallback failed, ret %{public}d", __func__, ret);
356 }
357 HDF_LOGI("#####%{public}s: %{public}d:", __func__, __LINE__);
358 EXPECT_EQ(ret, INPUT_SUCCESS);
359 }
360
361 HWTEST_F(InputManagerImplTetst, RegisterHotPlugCallback1, TestSize.Level0)
362 {
363 int32_t ret;
364 static OHOS::sptr<InputReportEventCallback> callback1 = new InputReportEventCallback();
365 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service1");
366 EXPECT_EQ(InputHostObj, nullptr);
367 }
368
369 HWTEST_F(InputManagerImplTetst, UnregisterHotPlugCallback, TestSize.Level0)
370 {
371 HDF_LOGI("%{public}s: [Input] GetDeviceType enter", __func__);
372 int32_t ret;
373 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service");
374 ASSERT_TRUE(InputHostObj != nullptr);
375 ret = InputHostObj->UnregisterHotPlugCallback();
376 if (ret) {
377 HDF_LOGE("%{public}s:UnregisterHotPlugCallback failed, ret %{public}d", __func__, ret);
378 }
379 HDF_LOGI("#####%{public}s: %{public}d:", __func__, __LINE__);
380 EXPECT_EQ(ret, INPUT_SUCCESS);
381 }
382
383 HWTEST_F(InputManagerImplTetst, UnregisterHotPlugCallback1, TestSize.Level0)
384 {
385 HDF_LOGI("%{public}s: [Input] GetDeviceType enter", __func__);
386 int32_t ret;
387 OHOS::sptr<IInputHost> InputHostObj = IInputHost::Get("input_service2");
388 EXPECT_EQ(InputHostObj, nullptr);
389 }
390
391