1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17
18 #include "device.h"
19 #include "device_manager.h"
20 #include "fi_log.h"
21
22 #undef LOG_TAG
23 #define LOG_TAG "DeviceTest"
24
25 namespace OHOS {
26 namespace Msdp {
27 namespace DeviceStatus {
28 using namespace testing::ext;
29
30 DeviceManager devmg_;
31 const std::string devNode_ = { "event0" };
32 const std::string devPath_ = { "/dev/input/event0" };
33 constexpr int32_t INDEX_TWO { 2 };
34 constexpr int32_t INDEX_THREE { 3 };
35 constexpr int32_t INDEX_NINE { 9 };
36 constexpr int32_t INDEX_TWELVE { 12 };
37 constexpr int32_t INDEX_TWENTY_THREE { 23 };
38 constexpr int32_t NUM_ONE { 1 };
39 constexpr int32_t NUM_SIXTY_FOUR { 64 };
40 constexpr int32_t NUM_HUNDRED_TWENTY_EIGHT { 128 };
41 constexpr int32_t NUM_THIRTY_TWO { 32 };
42 constexpr int32_t NUM_TWO { 2 };
43 int32_t deviceId_ = devmg_.ParseDeviceId(devNode_);
44
45 class DeviceTest : public testing::Test {
46 public:
SetUpTestCase()47 static void SetUpTestCase() {};
TearDownTestCase()48 static void TearDownTestCase() {};
SetUp()49 void SetUp() {};
TearDown()50 void TearDown() {};
51 };
52
53 /**
54 * @tc.name: OpenTest001
55 * @tc.desc: Test func named open device
56 * @tc.type: FUNC
57 */
HWTEST_F(DeviceTest, OpenTest001, TestSize.Level0)58 HWTEST_F(DeviceTest, OpenTest001, TestSize.Level0)
59 {
60 CALL_TEST_DEBUG;
61 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
62 Device *dev = new Device(deviceId);
63 CHKPV(dev);
64 dev->SetDevPath(devPath_);
65 int32_t ret = dev->Open();
66 EXPECT_EQ(ret, RET_OK);
67 dev->Close();
68 }
69
70 /**
71 * @tc.name: OpenTest002
72 * @tc.desc: Test func named open device
73 * @tc.type: FUNC
74 */
HWTEST_F(DeviceTest, OpenTest002, TestSize.Level0)75 HWTEST_F(DeviceTest, OpenTest002, TestSize.Level0)
76 {
77 CALL_TEST_DEBUG;
78 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
79 Device *dev = new Device(deviceId);
80 CHKPV(dev);
81 int32_t ret = dev->Open();
82 EXPECT_EQ(ret, RET_ERR);
83 }
84
85 /**
86 * @tc.name: CloseTest001
87 * @tc.desc: Test func named close device
88 * @tc.type: FUNC
89 */
HWTEST_F(DeviceTest, CloseTest001, TestSize.Level0)90 HWTEST_F(DeviceTest, CloseTest001, TestSize.Level0)
91 {
92 CALL_TEST_DEBUG;
93 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
94 Device *dev = new Device(deviceId);
95 CHKPV(dev);
96 ASSERT_NO_FATAL_FAILURE(dev->Close());
97 }
98
99 /**
100 * @tc.name: QueryDeviceInfoTest001
101 * @tc.desc: Test func named QueryDeviceInfo
102 * @tc.type: FUNC
103 */
HWTEST_F(DeviceTest, QueryDeviceInfoTest001, TestSize.Level0)104 HWTEST_F(DeviceTest, QueryDeviceInfoTest001, TestSize.Level0)
105 {
106 CALL_TEST_DEBUG;
107 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
108 Device *dev = new Device(deviceId);
109 CHKPV(dev);
110 ASSERT_NO_FATAL_FAILURE(dev->QueryDeviceInfo());
111 delete dev;
112 dev = nullptr;
113 }
114
115 /**
116 * @tc.name: CheckAbsTest001
117 * @tc.desc: Test func named CheckAbs
118 * @tc.type: FUNC
119 */
HWTEST_F(DeviceTest, CheckAbsTest001, TestSize.Level0)120 HWTEST_F(DeviceTest, CheckAbsTest001, TestSize.Level0)
121 {
122 CALL_TEST_DEBUG;
123 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
124 Device *dev = new Device(deviceId);
125 CHKPV(dev);
126 ASSERT_NO_FATAL_FAILURE(dev->CheckAbs());
127 delete dev;
128 dev = nullptr;
129 }
130
131 /**
132 * @tc.name: CheckMtTest001
133 * @tc.desc: Test func named CheckMt
134 * @tc.type: FUNC
135 */
HWTEST_F(DeviceTest, CheckMtTest001, TestSize.Level0)136 HWTEST_F(DeviceTest, CheckMtTest001, TestSize.Level0)
137 {
138 CALL_TEST_DEBUG;
139 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
140 Device *dev = new Device(deviceId);
141 CHKPV(dev);
142 ASSERT_NO_FATAL_FAILURE(dev->CheckMt());
143 delete dev;
144 dev = nullptr;
145 }
146
147 /**
148 * @tc.name: ReadConfigFileTest001
149 * @tc.desc: Test func named ReadConfigFile
150 * @tc.type: FUNC
151 */
HWTEST_F(DeviceTest, ReadConfigFileTest001, TestSize.Level0)152 HWTEST_F(DeviceTest, ReadConfigFileTest001, TestSize.Level0)
153 {
154 CALL_TEST_DEBUG;
155 const std::string filePath = { "/system/etc/device_status/drag_icon/Copy_Drag.svg" };
156 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
157 Device *dev = new Device(deviceId);
158 CHKPV(dev);
159 int32_t ret = dev->ReadConfigFile(filePath);
160 EXPECT_EQ(ret, RET_ERR);
161 delete dev;
162 dev = nullptr;
163 }
164
165 /**
166 * @tc.name: ReadConfigFileTest002
167 * @tc.desc: Test func named ReadConfigFile
168 * @tc.type: FUNC
169 */
HWTEST_F(DeviceTest, ReadConfigFileTest002, TestSize.Level0)170 HWTEST_F(DeviceTest, ReadConfigFileTest002, TestSize.Level0)
171 {
172 CALL_TEST_DEBUG;
173 const std::string filePath = "";
174 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
175 Device *dev = new Device(deviceId);
176 CHKPV(dev);
177 int32_t ret = dev->ReadConfigFile(filePath);
178 EXPECT_EQ(ret, RET_ERR);
179 delete dev;
180 dev = nullptr;
181 }
182
183 /**
184 * @tc.name: ConfigItemSwitchTest001
185 * @tc.desc: Test func named ConfigItemSwitch
186 * @tc.type: FUNC
187 */
HWTEST_F(DeviceTest, ConfigItemSwitchTest001, TestSize.Level0)188 HWTEST_F(DeviceTest, ConfigItemSwitchTest001, TestSize.Level0)
189 {
190 CALL_TEST_DEBUG;
191 std::string configItem = "123456";
192 std::string value = "123456";
193 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
194 Device *dev = new Device(deviceId);
195 CHKPV(dev);
196 int32_t ret = dev->ConfigItemSwitch(configItem, value);
197 EXPECT_EQ(ret, RET_OK);
198 delete dev;
199 dev = nullptr;
200 }
201
202 /**
203 * @tc.name: ConfigItemSwitchTest002
204 * @tc.desc: Test func named ConfigItemSwitch
205 * @tc.type: FUNC
206 */
HWTEST_F(DeviceTest, ConfigItemSwitchTest002, TestSize.Level0)207 HWTEST_F(DeviceTest, ConfigItemSwitchTest002, TestSize.Level0)
208 {
209 CALL_TEST_DEBUG;
210 std::string configItem = "";
211 std::string value = "123456";
212 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
213 Device *dev = new Device(deviceId);
214 CHKPV(dev);
215 int32_t ret = dev->ConfigItemSwitch(configItem, value);
216 EXPECT_EQ(ret, RET_ERR);
217 delete dev;
218 dev = nullptr;
219 }
220
221 /**
222 * @tc.name: ConfigItemSwitchTest003
223 * @tc.desc: Test func named ConfigItemSwitch
224 * @tc.type: FUNC
225 */
HWTEST_F(DeviceTest, ConfigItemSwitchTest003, TestSize.Level0)226 HWTEST_F(DeviceTest, ConfigItemSwitchTest003, TestSize.Level0)
227 {
228 CALL_TEST_DEBUG;
229 std::string configItem = "1234567";
230 std::string value = "";
231 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
232 Device *dev = new Device(deviceId);
233 CHKPV(dev);
234 int32_t ret = dev->ConfigItemSwitch(configItem, value);
235 EXPECT_EQ(ret, RET_ERR);
236 delete dev;
237 dev = nullptr;
238 }
239
240 /**
241 * @tc.name: ReadTomlFileTest001
242 * @tc.desc: Test func named ReadTomlFile
243 * @tc.type: FUNC
244 */
HWTEST_F(DeviceTest, ReadTomlFileTest001, TestSize.Level0)245 HWTEST_F(DeviceTest, ReadTomlFileTest001, TestSize.Level0)
246 {
247 CALL_TEST_DEBUG;
248 const std::string filePath = { "/system/etc/device_status/drag_icon/Copy_Drag.svg" };
249 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
250 Device *dev = new Device(deviceId);
251 CHKPV(dev);
252 int32_t ret = dev->ReadTomlFile(filePath);
253 EXPECT_EQ(ret, RET_ERR);
254 delete dev;
255 dev = nullptr;
256 }
257
258 /**
259 * @tc.name: HasRelCoordTest001
260 * @tc.desc: Test func named HasRelCoord
261 * @tc.type: FUNC
262 */
HWTEST_F(DeviceTest, HasRelCoordTest001, TestSize.Level0)263 HWTEST_F(DeviceTest, HasRelCoordTest001, TestSize.Level0)
264 {
265 CALL_TEST_DEBUG;
266 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
267 Device *dev = new Device(deviceId);
268 CHKPV(dev);
269 bool ret = dev->HasRelCoord();
270 EXPECT_EQ(ret, false);
271 delete dev;
272 dev = nullptr;
273 }
274
275 /**
276 * @tc.name: DispatchTest001
277 * @tc.desc: Test func named Dispatch
278 * @tc.type: FUNC
279 */
HWTEST_F(DeviceTest, DispatchTest001, TestSize.Level0)280 HWTEST_F(DeviceTest, DispatchTest001, TestSize.Level0)
281 {
282 CALL_TEST_DEBUG;
283 const struct epoll_event ev {};
284 int32_t deviceId = devmg_.ParseDeviceId(devNode_);
285 Device *dev = new Device(deviceId);
286 CHKPV(dev);
287 ASSERT_NO_FATAL_FAILURE(dev->Dispatch(ev));
288 delete dev;
289 dev = nullptr;
290 }
291
292 /**
293 * @tc.name: JudgeKeyboardTypeTest001
294 * @tc.desc: Test func named JudgeKeyboardType
295 * @tc.type: FUNC
296 */
HWTEST_F(DeviceTest, JudgeKeyboardTypeTest001, TestSize.Level0)297 HWTEST_F(DeviceTest, JudgeKeyboardTypeTest001, TestSize.Level0)
298 {
299 CALL_TEST_DEBUG;
300 Device dev(deviceId_);
301 dev.keyBitmask_[INDEX_TWO] = NUM_ONE;
302 ASSERT_NO_FATAL_FAILURE(dev.JudgeKeyboardType());
303 }
304
305 /**
306 * @tc.name: JudgeKeyboardTypeTest002
307 * @tc.desc: Test func named JudgeKeyboardType
308 * @tc.type: FUNC
309 */
HWTEST_F(DeviceTest, JudgeKeyboardTypeTest002, TestSize.Level0)310 HWTEST_F(DeviceTest, JudgeKeyboardTypeTest002, TestSize.Level0)
311 {
312 CALL_TEST_DEBUG;
313 Device dev(deviceId_);
314 dev.keyBitmask_[INDEX_TWELVE] = NUM_SIXTY_FOUR;
315 dev.bus_ = BUS_BLUETOOTH;
316 ASSERT_NO_FATAL_FAILURE(dev.JudgeKeyboardType());
317 }
318
319 /**
320 * @tc.name: JudgeKeyboardTypeTest003
321 * @tc.desc: Test func named JudgeKeyboardType
322 * @tc.type: FUNC
323 */
HWTEST_F(DeviceTest, JudgeKeyboardTypeTest003, TestSize.Level0)324 HWTEST_F(DeviceTest, JudgeKeyboardTypeTest003, TestSize.Level0)
325 {
326 CALL_TEST_DEBUG;
327 Device dev(deviceId_);
328 dev.keyBitmask_[INDEX_NINE] = NUM_HUNDRED_TWENTY_EIGHT;
329 ASSERT_NO_FATAL_FAILURE(dev.JudgeKeyboardType());
330 }
331
332 /**
333 * @tc.name: JudgeKeyboardTypeTest004
334 * @tc.desc: Test func named JudgeKeyboardType
335 * @tc.type: FUNC
336 */
HWTEST_F(DeviceTest, JudgeKeyboardTypeTest004, TestSize.Level0)337 HWTEST_F(DeviceTest, JudgeKeyboardTypeTest004, TestSize.Level0)
338 {
339 CALL_TEST_DEBUG;
340 Device dev(deviceId_);
341 dev.keyBitmask_[INDEX_THREE] = NUM_THIRTY_TWO;
342 ASSERT_NO_FATAL_FAILURE(dev.JudgeKeyboardType());
343 }
344
345 /**
346 * @tc.name: JudgeKeyboardTypeTest005
347 * @tc.desc: Test func named JudgeKeyboardType
348 * @tc.type: FUNC
349 */
HWTEST_F(DeviceTest, JudgeKeyboardTypeTest005, TestSize.Level0)350 HWTEST_F(DeviceTest, JudgeKeyboardTypeTest005, TestSize.Level0)
351 {
352 CALL_TEST_DEBUG;
353 Device dev(deviceId_);
354 dev.keyBitmask_[INDEX_THREE] = NUM_THIRTY_TWO;
355 dev.keyBitmask_[INDEX_TWELVE] = NUM_TWO;
356 ASSERT_NO_FATAL_FAILURE(dev.JudgeKeyboardType());
357 }
358
359 /**
360 * @tc.name: JudgeKeyboardTypeTest006
361 * @tc.desc: Test func named JudgeKeyboardType
362 * @tc.type: FUNC
363 */
HWTEST_F(DeviceTest, JudgeKeyboardTypeTest006, TestSize.Level0)364 HWTEST_F(DeviceTest, JudgeKeyboardTypeTest006, TestSize.Level0)
365 {
366 CALL_TEST_DEBUG;
367 Device dev(deviceId_);
368 dev.keyBitmask_[INDEX_THREE] = NUM_THIRTY_TWO;
369 dev.keyBitmask_[INDEX_TWELVE] = NUM_TWO;
370 dev.keyBitmask_[INDEX_TWENTY_THREE] = NUM_SIXTY_FOUR;
371 ASSERT_NO_FATAL_FAILURE(dev.JudgeKeyboardType());
372 }
373 } // namespace DeviceStatus
374 } // namespace Msdp
375 } // namespace OHOS
