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