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 <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
309 /**
310 * @tc.name: TestOnPointerEvent_01
311 * @tc.desc: Test OnPointerEvent
312 * @tc.type: FUNC
313 * @tc.require:
314 */
315 HWTEST_F(InputEventSamplerTest, TestOnPointerEvent_01, TestSize.Level1)
316 {
317 CALL_TEST_DEBUG;
318 auto pointerEvent = MMI::PointerEvent::Create();
319 ASSERT_NE(pointerEvent, nullptr);
320 Cooperate::InputEventSampler sampler;
321 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_ENTER_WINDOW);
322 int32_t ret = sampler.IsSkipNeeded(pointerEvent);
323 ASSERT_EQ(ret, true);
324 sampler.OnPointerEvent(pointerEvent);
325 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
326 int32_t ret1 = sampler.IsSkipNeeded(pointerEvent);
327 ASSERT_EQ(ret1, false);
328 sampler.OnPointerEvent(pointerEvent);
329 }
330
331 /**
332 * @tc.name: TestOnPointerEvent_02
333 * @tc.desc: Test OnPointerEvent
334 * @tc.type: FUNC
335 * @tc.require:
336 */
337 HWTEST_F(InputEventSamplerTest, TestOnPointerEvent_02, TestSize.Level1)
338 {
339 CALL_TEST_DEBUG;
340 auto pointerEvent = MMI::PointerEvent::Create();
341 ASSERT_NE(pointerEvent, nullptr);
342 Cooperate::InputEventSampler sampler;
343 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_ENTER_WINDOW);
344 int32_t ret = sampler.IsSkipNeeded(pointerEvent);
345 ASSERT_EQ(ret, true);
346 int32_t ret1 = sampler.IsRawEventsExpired();
347 ASSERT_EQ(ret1, false);
348 sampler.OnPointerEvent(pointerEvent);
349 }
350
351 /**
352 * @tc.name: TestAggregateRawEvents_01
353 * @tc.desc: Test AggregateRawEvents
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(InputEventSamplerTest, TestAggregateRawEvents_02, TestSize.Level1)
358 {
359 CALL_TEST_DEBUG;
360 auto pointerEvent = MMI::PointerEvent::Create();
361 ASSERT_NE(pointerEvent, nullptr);
362 Cooperate::InputEventSampler sampler;
363 ASSERT_NO_FATAL_FAILURE(sampler.AggregateRawEvents(pointerEvent));
364 pointerEvent->SetPointerId(1);
365 MMI::PointerEvent::PointerItem pointerItem;
366 pointerItem.SetPointerId(1);
367 pointerItem.SetDeviceId(1);
368 pointerItem.SetDisplayX(0);
369 pointerItem.SetDisplayY(0);
370 pointerEvent->AddPointerItem(pointerItem);
371 ASSERT_NO_FATAL_FAILURE(sampler.AggregateRawEvents(pointerEvent));
372 }
373
374 /**
375 * @tc.name: TesHandleMouseEvent_01
376 * @tc.desc: Test HandleMouseEvent
377 * @tc.type: FUNC
378 * @tc.require:
379 */
380 HWTEST_F(InputEventSamplerTest, TestHandleMouseEvent_01, TestSize.Level1)
381 {
382 CALL_TEST_DEBUG;
383 auto pointerEvent = MMI::PointerEvent::Create();
384 ASSERT_NE(pointerEvent, nullptr);
385 Cooperate::InputEventSampler sampler;
386 MMI::PointerEvent::PointerItem pointerItem;
387 pointerItem.SetPointerId(1);
388 pointerItem.SetDeviceId(1);
389 pointerItem.SetDisplayX(0);
390 pointerItem.SetDisplayY(0);
391 pointerEvent->AddPointerItem(pointerItem);
392 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_ENTER_WINDOW);
393 int32_t ret = sampler.IsSpecialEvent(pointerEvent);
394 ASSERT_EQ(ret, true);
395 sampler.HandleMouseEvent(pointerEvent);
396 }
397
398 /**
399 * @tc.name: TestOnDownSampledEvent_01
400 * @tc.desc: Test OnDownSampledEvent
401 * @tc.type: FUNC
402 * @tc.require:
403 */
404 HWTEST_F(InputEventSamplerTest, TestOnDownSampledEvent_01, TestSize.Level1)
405 {
406 CALL_TEST_DEBUG;
407 auto pointerEvent = MMI::PointerEvent::Create();
408 ASSERT_NE(pointerEvent, nullptr);
409 Cooperate::InputEventSampler sampler;
410 sampler.HandleTouchPadEvent(pointerEvent);
411 ASSERT_NO_FATAL_FAILURE(sampler.OnDownSampledEvent());
412 }
413
414 /**
415 * @tc.name: TestIsAggregationIntervalMatched_01
416 * @tc.desc: Test IsAggregationIntervalMatched
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 HWTEST_F(InputEventSamplerTest, TestIsAggregationIntervalMatched_01, TestSize.Level1)
421 {
422 CALL_TEST_DEBUG;
423 auto pointerEvent = MMI::PointerEvent::Create();
424 ASSERT_NE(pointerEvent, nullptr);
425 Cooperate::InputEventSampler sampler;
426 sampler.UpdateAggregationTimeStamp();
427 ASSERT_NO_FATAL_FAILURE(sampler.IsAggregationIntervalMatched());
428 }
429 } // namespace DeviceStatus
430 } // namespace Msdp
431 } // namespace OHOS