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