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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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