1 /*
2 * Copyright (c) 2025 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 <future>
17 #include <memory>
18 #include <optional>
19 #include <utility>
20 #include <vector>
21 #include <gtest/gtest.h>
22
23 #include "devicestatus_define.h"
24 #include "input_event_interceptor.h"
25 #include "input_event_sampler.h"
26
27 #undef LOG_TAG
28 #define LOG_TAG "InputEventSamplerTest"
29
30 namespace OHOS {
31 namespace Msdp {
32 namespace DeviceStatus {
33 using namespace testing::ext;
34 namespace {
35 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
36 constexpr int32_t TEMP_RAW { 10 };
37 constexpr int32_t TEMP_MIN_RAW { 0 };
38 } // namespace
39
40 class InputEventSamplerTest : public testing::Test {
41 public:
42 void SetUp();
43 void TearDown();
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 };
47
SetUpTestCase()48 void InputEventSamplerTest::SetUpTestCase() {}
49
TearDownTestCase()50 void InputEventSamplerTest::TearDownTestCase() {}
51
SetUp()52 void InputEventSamplerTest::SetUp() {}
53
TearDown()54 void InputEventSamplerTest::TearDown()
55 {
56 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
57 }
58
59 /**
60 * @tc.name: TestIsTouchPadEvent_01
61 * @tc.desc: Test IsTouchPadEvent
62 * @tc.type: FUNC
63 * @tc.require:
64 */
65 HWTEST_F(InputEventSamplerTest, TestIsTouchPadEvent_01, TestSize.Level1)
66 {
67 CALL_TEST_DEBUG;
68 auto pointerEvent = MMI::PointerEvent::Create();
69 ASSERT_NE(pointerEvent, nullptr);
70 Cooperate::InputEventSampler sampler;
71 int32_t ret = sampler.IsTouchPadEvent(pointerEvent);
72 ASSERT_EQ(ret, false);
73 pointerEvent = nullptr;
74 ret = sampler.IsTouchPadEvent(pointerEvent);
75 ASSERT_EQ(ret, false);
76 }
77
78 /**
79 * @tc.name: TestIsTouchPadEvent_02
80 * @tc.desc: Test IsTouchPadEvent
81 * @tc.type: FUNC
82 * @tc.require:
83 */
84 HWTEST_F(InputEventSamplerTest, TestIsTouchPadEvent_02, TestSize.Level1)
85 {
86 CALL_TEST_DEBUG;
87 auto pointerEvent = MMI::PointerEvent::Create();
88 ASSERT_NE(pointerEvent, nullptr);
89 MMI::PointerEvent::PointerItem pointerItem;
90 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
91 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
92 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
93 Cooperate::InputEventSampler sampler;
94 int32_t ret = sampler.IsTouchPadEvent(pointerEvent);
95 ASSERT_EQ(ret, false);
96 }
97
98 /**
99 * @tc.name: TestIsSpecialEvent_01
100 * @tc.desc: Test IsSpecialEvent
101 * @tc.type: FUNC
102 * @tc.require:
103 */
104 HWTEST_F(InputEventSamplerTest, TestIsSpecialEvent_01, TestSize.Level1)
105 {
106 CALL_TEST_DEBUG;
107 auto pointerEvent = MMI::PointerEvent::Create();
108 ASSERT_NE(pointerEvent, nullptr);
109 Cooperate::InputEventSampler sampler;
110 int32_t ret = sampler.IsSpecialEvent(pointerEvent);
111 ASSERT_EQ(ret, true);
112 pointerEvent = nullptr;
113 ret = sampler.IsSpecialEvent(pointerEvent);
114 ASSERT_EQ(ret, false);
115 }
116
117 /**
118 * @tc.name: TestIsSpecialEvent_02
119 * @tc.desc: Test IsSpecialEvent
120 * @tc.type: FUNC
121 * @tc.require:
122 */
123 HWTEST_F(InputEventSamplerTest, TestIsSpecialEvent_02, TestSize.Level1)
124 {
125 CALL_TEST_DEBUG;
126 auto pointerEvent = MMI::PointerEvent::Create();
127 ASSERT_NE(pointerEvent, nullptr);
128 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
129 Cooperate::InputEventSampler sampler;
130 int32_t ret = sampler.IsSpecialEvent(pointerEvent);
131 ASSERT_EQ(ret, false);
132 }
133
134 /**
135 * @tc.name: TestIsDurationMatched_01
136 * @tc.desc: Test IsDurationMatched
137 * @tc.type: FUNC
138 * @tc.require:
139 */
140 HWTEST_F(InputEventSamplerTest, TestIsDurationMatched_01, TestSize.Level1)
141 {
142 CALL_TEST_DEBUG;
143 Cooperate::InputEventSampler sampler;
144 int32_t ret = sampler.IsDurationMatched();
145 ASSERT_EQ(ret, false);
146 auto pointerEvent = MMI::PointerEvent::Create();
147 ASSERT_NE(pointerEvent, nullptr);
148 sampler.rawEvents_.push({pointerEvent, std::chrono::steady_clock::now()});
149 ret = sampler.IsDurationMatched();
150 ASSERT_EQ(ret, false);
151 }
152
153 /**
154 * @tc.name: TestIsOffsetMatched_01
155 * @tc.desc: Test IsOffsetMatched
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(InputEventSamplerTest, TestIsOffsetMatched_01, TestSize.Level1)
160 {
161 CALL_TEST_DEBUG;
162 Cooperate::InputEventSampler sampler;
163 auto pointerEvent = MMI::PointerEvent::Create();
164 ASSERT_NE(pointerEvent, nullptr);
165 sampler.prefixRawDxSum_ = TEMP_RAW;
166 sampler.prefixRawDySum_ = TEMP_RAW;
167 sampler.rawDxThreshold_ = TEMP_MIN_RAW;
168 sampler.rawDyThreshold_ = TEMP_MIN_RAW;
169 int32_t ret = sampler.IsOffsetMatched(pointerEvent);
170 ASSERT_EQ(ret, false);
171 pointerEvent = nullptr;
172 ret = sampler.IsOffsetMatched(pointerEvent);
173 ASSERT_EQ(ret, false);
174 }
175
176 /**
177 * @tc.name: TestIsOffsetMatched_02
178 * @tc.desc: Test IsOffsetMatched
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(InputEventSamplerTest, TestIsOffsetMatched_02, TestSize.Level1)
183 {
184 CALL_TEST_DEBUG;
185 Cooperate::InputEventSampler sampler;
186 auto pointerEvent = MMI::PointerEvent::Create();
187 ASSERT_NE(pointerEvent, nullptr);
188 sampler.prefixRawDxSum_ = TEMP_MIN_RAW;
189 sampler.prefixRawDySum_ = TEMP_MIN_RAW;
190 sampler.rawDxThreshold_ = TEMP_RAW;
191 sampler.rawDyThreshold_ = TEMP_RAW;
192 int32_t ret = sampler.IsOffsetMatched(pointerEvent);
193 ASSERT_EQ(ret, false);
194 }
195
196 /**
197 * @tc.name: TestIsOffsetMatched_03
198 * @tc.desc: Test IsOffsetMatched
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(InputEventSamplerTest, TestIsOffsetMatched_03, TestSize.Level1)
203 {
204 CALL_TEST_DEBUG;
205 Cooperate::InputEventSampler sampler;
206 auto pointerEvent = MMI::PointerEvent::Create();
207 ASSERT_NE(pointerEvent, nullptr);
208 sampler.prefixRawDxSum_ = TEMP_RAW;
209 sampler.prefixRawDySum_ = TEMP_MIN_RAW;
210 sampler.rawDxThreshold_ = TEMP_MIN_RAW;
211 sampler.rawDyThreshold_ = TEMP_RAW;
212 int32_t ret = sampler.IsOffsetMatched(pointerEvent);
213 ASSERT_EQ(ret, false);
214 }
215
216 /**
217 * @tc.name: TestIsOffsetMatched_04
218 * @tc.desc: Test IsOffsetMatched
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222 HWTEST_F(InputEventSamplerTest, TestIsOffsetMatched_04, TestSize.Level1)
223 {
224 CALL_TEST_DEBUG;
225 Cooperate::InputEventSampler sampler;
226 auto pointerEvent = MMI::PointerEvent::Create();
227 ASSERT_NE(pointerEvent, nullptr);
228 sampler.prefixRawDxSum_ = TEMP_MIN_RAW;
229 sampler.prefixRawDySum_ = TEMP_RAW;
230 sampler.rawDxThreshold_ = TEMP_RAW;
231 sampler.rawDyThreshold_ = TEMP_MIN_RAW;
232 int32_t ret = sampler.IsOffsetMatched(pointerEvent);
233 ASSERT_EQ(ret, false);
234 }
235
236 /**
237 * @tc.name: TestIsRawEventsExpired_01
238 * @tc.desc: Test IsRawEventsExpired
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(InputEventSamplerTest, TestIsRawEventsExpired_01, TestSize.Level1)
243 {
244 CALL_TEST_DEBUG;
245 Cooperate::InputEventSampler sampler;
246 int32_t ret = sampler.IsRawEventsExpired();
247 ASSERT_EQ(ret, false);
248 auto pointerEvent = MMI::PointerEvent::Create();
249 pointerEvent = nullptr;
250 sampler.rawEvents_.push({pointerEvent, std::chrono::steady_clock::now()});
251 ret = sampler.IsRawEventsExpired();
252 ASSERT_EQ(ret, false);
253 }
254
255 /**
256 * @tc.name: TestIsRawEventsExpired_02
257 * @tc.desc: Test IsRawEventsExpired
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(InputEventSamplerTest, TestIsRawEventsExpired_02, TestSize.Level1)
262 {
263 CALL_TEST_DEBUG;
264 Cooperate::InputEventSampler sampler;
265 auto pointerEvent = MMI::PointerEvent::Create();
266 ASSERT_NE(pointerEvent, nullptr);
267 sampler.rawEvents_.push({pointerEvent, std::chrono::steady_clock::now()});
268 int32_t ret = sampler.IsRawEventsExpired();
269 ASSERT_EQ(ret, false);
270 }
271
272 /**
273 * @tc.name: TestIsSkipNeeded_01
274 * @tc.desc: Test IsSkipNeeded
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 HWTEST_F(InputEventSamplerTest, TestIsSkipNeeded_01, TestSize.Level1)
279 {
280 CALL_TEST_DEBUG;
281 Cooperate::InputEventSampler sampler;
282 auto pointerEvent = MMI::PointerEvent::Create();
283 ASSERT_NE(pointerEvent, nullptr);
284 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_ENTER_WINDOW);
285 int32_t ret = sampler.IsSkipNeeded(pointerEvent);
286 ASSERT_EQ(ret, true);
287 pointerEvent = nullptr;
288 ret = sampler.IsSkipNeeded(pointerEvent);
289 ASSERT_EQ(ret, true);
290 }
291
292 /**
293 * @tc.name: TestIsSkipNeeded_02
294 * @tc.desc: Test IsSkipNeeded
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(InputEventSamplerTest, TestIsSkipNeeded_02, TestSize.Level1)
299 {
300 CALL_TEST_DEBUG;
301 Cooperate::InputEventSampler sampler;
302 auto pointerEvent = MMI::PointerEvent::Create();
303 ASSERT_NE(pointerEvent, nullptr);
304 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
305 int32_t ret = sampler.IsSkipNeeded(pointerEvent);
306 ASSERT_EQ(ret, false);
307 }
308 } // namespace DeviceStatus
309 } // namespace Msdp
310 } // namespace OHOS