1 /*
2 * Copyright (c) 2022 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 <clocale>
17 #include <cmath>
18 #include <cstdint>
19 #include <unistd.h>
20
21 #include "gtest/gtest.h"
22 #define private public
23 #define protected public
24
25 #include "test/mock/core/pipeline/mock_pipeline_context.h"
26
27 #include "core/common/ace_application_info.h"
28 #include "core/components_ng/event/event_hub.h"
29 #include "core/components_ng/event/response_ctrl.h"
30 #include "core/components_ng/event/touch_event.h"
31 #include "core/components_ng/pattern/stage/page_pattern.h"
32 #include "core/components_v2/inspector/inspector_constants.h"
33
34 using namespace testing;
35 using namespace testing::ext;
36
37 namespace OHOS::Ace::NG {
38 namespace {
39 constexpr bool STOP_PROPAGATION_VALUE = true;
40 constexpr int32_t TOUCH_TEST_RESULT_SIZE_1 = 1;
41 constexpr uint32_t TOUCH_EVENTS_SIZE = 1;
42 constexpr uint32_t TOUCH_EVENTS_SIZE_2 = 2;
43 const TouchRestrict Touch_TOUCH_RESTRICT = { TouchRestrict::LONG_PRESS };
44 constexpr float TILT_X_VALUE = 400.0f;
45 constexpr float TILT_Y_VALUE = 400.0f;
46 constexpr float WIDTH = 400.0f;
47 constexpr float HEIGHT = 400.0f;
48 const OffsetF COORDINATE_OFFSET(WIDTH, HEIGHT);
49 const std::string TOUCH_EVENT_INFO_TYPE = "onTouchDown";
50 const std::vector<TouchPoint> POINTERS = { TouchPoint(), TouchPoint(), TouchPoint() };
51 const std::vector<TouchPoint> POINTERS_2 = { { .tiltX = TILT_X_VALUE, .tiltY = TILT_Y_VALUE } };
52 constexpr int32_t DEFAULT_PEN_ID = 102;
53 constexpr int32_t DEFAULT_MOUSE_ID = 1001;
54 } // namespace
55
56 class TouchEventTestNg : public testing::Test {
57 public:
58 static void SetUpTestSuite();
59 static void TearDownTestSuite();
60 void SetUp() override;
61 void TearDown() override;
62 };
63
SetUpTestSuite()64 void TouchEventTestNg::SetUpTestSuite()
65 {
66 GTEST_LOG_(INFO) << "TouchEventTestNg SetUpTestCase";
67 }
68
TearDownTestSuite()69 void TouchEventTestNg::TearDownTestSuite()
70 {
71 GTEST_LOG_(INFO) << "TouchEventTestNg TearDownTestCase";
72 }
73
SetUp()74 void TouchEventTestNg::SetUp()
75 {
76 MockPipelineContext::SetUp();
77 }
78
TearDown()79 void TouchEventTestNg::TearDown()
80 {
81 MockPipelineContext::TearDown();
82 }
83
84 /**
85 * @tc.name: TouchEventCreateTest001
86 * @tc.desc: Create TouchEvent and execute its callback functions.
87 * @tc.type: FUNC
88 */
89 HWTEST_F(TouchEventTestNg, TouchEventCreateTest001, TestSize.Level1)
90 {
91 /**
92 * @tc.steps: step1. Create TouchEvent.
93 */
94 std::string unknownType;
__anond021ad580202(TouchEventInfo& info) 95 TouchEventFunc callback = [&unknownType](TouchEventInfo& info) { unknownType = info.GetType(); };
96 const TouchEventImpl touchEvent = TouchEventImpl(std::move(callback));
97
98 /**
99 * @tc.steps: step2. Get and execute TouchEvent callback function.
100 * @tc.expected: Execute callback where unknownPropertyValue is assigned in.
101 */
102 TouchEventInfo info(TOUCH_EVENT_INFO_TYPE);
103 touchEvent(info);
104 EXPECT_EQ(unknownType, TOUCH_EVENT_INFO_TYPE);
105 }
106
107 /**
108 * @tc.name: TouchEventActuatorTest002
109 * @tc.desc: Create TouchEventActuator and replace, add and remove touchEvent.
110 * @tc.type: FUNC
111 */
112 HWTEST_F(TouchEventTestNg, TouchEventActuatorTest002, TestSize.Level1)
113 {
114 /**
115 * @tc.steps: step1. Create TouchEventActuator.
116 * @tc.expected: touchEventActuator is not nullptr.
117 */
118 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
119 EXPECT_NE(touchEventActuator, nullptr);
120
121 /**
122 * @tc.steps: step2. Replace TouchEventFunc when userCallback_ is nullptr.
123 * @tc.expected: userCallback_ will be reset and Make an new instance.
124 */
__anond021ad580302(TouchEventInfo& info) 125 const TouchEventFunc callback = [](TouchEventInfo& info) {};
126 TouchEventFunc callback1 = callback;
127 touchEventActuator->ReplaceTouchEvent(std::move(callback1));
128 EXPECT_NE(touchEventActuator->userCallback_, nullptr);
129
130 /**
131 * @tc.steps: step3. Add touch event when touchEvents_ is empty.
132 * @tc.expected: Add touch event to the list of touchEvents_.
133 */
134 TouchEventFunc callback2 = callback;
135 auto touchEvent2 = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback2));
136 touchEventActuator->AddTouchEvent(touchEvent2);
137 EXPECT_EQ(touchEventActuator->touchEvents_.size(), TOUCH_EVENTS_SIZE);
138
139 /**
140 * @tc.steps: step4. Add touch event when touchEvents_ is not empty.
141 * @tc.expected: Add touch event to the list of touchEvents_ where it is not found in.
142 */
143 TouchEventFunc callback3 = callback;
144 auto touchEvent3 = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback3));
145 touchEventActuator->AddTouchEvent(touchEvent3);
146 EXPECT_EQ(touchEventActuator->touchEvents_.size(), TOUCH_EVENTS_SIZE_2);
147
148 /**
149 * @tc.steps: step5. Remove touch event.
150 * @tc.expected: The list of touch event size will minus one.
151 */
152 touchEventActuator->RemoveTouchEvent(touchEvent3);
153 EXPECT_EQ(touchEventActuator->touchEvents_.size(), TOUCH_EVENTS_SIZE);
154 }
155
156 /**
157 * @tc.name: TouchEventActuatorOnCollectTouchTargetTest003
158 * @tc.desc: Create TouchEventActuator and Invoke OnCollectTouchTarget event.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(TouchEventTestNg, TouchEventActuatorOnCollectTouchTargetTest003, TestSize.Level1)
162 {
163 /**
164 * @tc.steps: step1. Create TouchEventActuator.
165 * @tc.expected: touchEventActuator is not nullptr.
166 */
167 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
168 EXPECT_NE(touchEventActuator, nullptr);
169
170 /**
171 * @tc.steps: step2. Invoke OnCollectTouchTarget.
172 * @tc.expected: TouchTestResult size has been increased one.
173 */
174 TouchTestResult result;
175 ResponseLinkResult responseLinkResult;
176 auto eventHub = AceType::MakeRefPtr<EventHub>();
177 touchEventActuator->OnCollectTouchTarget(
178 COORDINATE_OFFSET, Touch_TOUCH_RESTRICT, eventHub->CreateGetEventTargetImpl(), result, responseLinkResult);
179
180 EXPECT_EQ(touchEventActuator->coordinateOffset_, Offset(WIDTH, HEIGHT));
181 EXPECT_EQ(result.size(), TOUCH_TEST_RESULT_SIZE_1);
182 }
183
184 /**
185 * @tc.name: TouchEventActuatorHandleAndDispatchTest004
186 * @tc.desc: Create TouchEventActuator and replace, add and remove touchEvent.
187 * @tc.type: FUNC
188 */
189 HWTEST_F(TouchEventTestNg, TouchEventActuatorHandleAndDispatchTest004, TestSize.Level1)
190 {
191 /**
192 * @tc.steps: step1. Create TouchEventActuator.
193 * @tc.expected: touchEventActuator is not nullptr.
194 */
195 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
196 EXPECT_NE(touchEventActuator, nullptr);
197
198 /**
199 * @tc.steps: step2. Invoke DispatchEvent.
200 * @tc.expected: TouchTestResult size has been increased one.
201 */
202 TouchEvent touchEvent;
203 touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
204 EXPECT_TRUE(touchEventActuator->DispatchEvent(touchEvent));
205
206 /**
207 * @tc.steps: step3. Invoke HandleEvent when touchEvents_ and userCallback_ is empty.
208 * @tc.expected: HandleEvent will return true directly.
209 */
210 EXPECT_TRUE(touchEventActuator->HandleEvent(touchEvent));
211
212 /**
213 * @tc.steps: step4. Invoke ReplaceTouchEvent to initialize userCallback_.
214 */
215 double unknownTiltX = 0.0;
216 const TouchEventFunc callback = [&unknownTiltX](
__anond021ad580402( TouchEventInfo& info) 217 TouchEventInfo& info) { unknownTiltX = info.GetTiltX().value_or(0.0); };
218 TouchEventFunc callback1 = callback;
219 touchEventActuator->ReplaceTouchEvent(std::move(callback1));
220 EXPECT_NE(touchEventActuator->userCallback_, nullptr);
221
222 /**
223 * @tc.steps: step5. Invoke AddTouchEvent to add touch event to touchEvents_.
224 */
225 TouchEventFunc callback2 = callback;
226 auto touchEvent2 = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback2));
227 touchEventActuator->AddTouchEvent(touchEvent2);
228 touchEventActuator->AddTouchEvent(nullptr);
229 EXPECT_EQ(touchEventActuator->touchEvents_.size(), TOUCH_EVENTS_SIZE_2);
230
231 /**
232 * @tc.steps: step6. Invoke HandleEvent when touchEvents_ and userCallback_ is not empty.
233 * @tc.expected: HandleEvent will execute touchEvents_ and userCallback_ event where unknownTiltX was assigned the
234 * touchPoint value, and the function return true.
235 */
236 EXPECT_TRUE(touchEventActuator->HandleEvent(touchEvent));
237 EXPECT_NE(unknownTiltX, 0);
238
239 /**
240 * @tc.steps: step7. Invoke HandleEvent when touchEvents_ and userCallback_ is not empty but the event is
241 * stopPropagation_ is true.
242 * @tc.expected: HandleEvent return false;
243 */
__anond021ad580502(TouchEventInfo& info) 244 TouchEventFunc callback3 = [](TouchEventInfo& info) { info.SetStopPropagation(STOP_PROPAGATION_VALUE); };
245 touchEventActuator->ReplaceTouchEvent(std::move(callback3));
246 EXPECT_FALSE(touchEventActuator->HandleEvent(touchEvent));
247
248 /**
249 * @tc.steps: step8. Invoke HandleEvent when touchEvents_ has nullptr event and userCallback_ is nullptr.
250 * @tc.expected: HandleEvent return true;
251 */
252 touchEventActuator->userCallback_ = nullptr;
253 TouchEvent touchEvent3;
254 touchEvent3.SetPointers(POINTERS_2);
255 EXPECT_TRUE(touchEventActuator->HandleEvent(touchEvent3));
256
257 /**
258 * @tc.steps: step9. add history.
259 * @tc.expected: HandleEvent return TRUE;
260 */
261 TouchEvent touchEvent4 = touchEvent;
262 touchEvent4.history.push_back(touchEvent);
263 touchEvent4.history.push_back(touchEvent);
264 touchEvent4.history.push_back(touchEvent);
265 touchEvent4.isInterpolated = true;
266 EXPECT_TRUE(touchEventActuator->HandleEvent(touchEvent4));
267 }
268
269 /**
270 * @tc.name: TouchEventDisable001
271 * @tc.desc: Create TouchEventActuator and test disable.
272 * @tc.type: FUNC
273 */
274 HWTEST_F(TouchEventTestNg, TouchEventDisable001, TestSize.Level1)
275 {
276 /**
277 * @tc.steps: step1. Create TouchEventActuator.
278 * @tc.expected: touchEventActuator is not nullptr.
279 */
280 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
281 EXPECT_NE(touchEventActuator, nullptr);
282
283 /**
284 * @tc.steps: step2. Invoke DispatchEvent.
285 * @tc.expected: TouchTestResult size has been increased one.
286 */
287 TouchEvent touchEvent;
288 touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
289 EXPECT_TRUE(touchEventActuator->DispatchEvent(touchEvent));
290
291 /**
292 * @tc.steps: step3. Invoke HandleEvent when touchEvents_ and userCallback_ is empty.
293 * @tc.expected: HandleEvent will return true directly.
294 */
295 EXPECT_TRUE(touchEventActuator->HandleEvent(touchEvent));
296
297 /**
298 * @tc.steps: step4. Invoke ReplaceTouchEvent to initialize userCallback_.
299 */
300 double unknownTiltX = 0.0;
301 const TouchEventFunc callback = [&unknownTiltX](
__anond021ad580602( TouchEventInfo& info) 302 TouchEventInfo& info) { unknownTiltX = info.GetTiltX().value_or(0.0); };
303 TouchEventFunc callback1 = callback;
304 touchEventActuator->ReplaceTouchEvent(std::move(callback1));
305 EXPECT_NE(touchEventActuator->userCallback_, nullptr);
306
307 EXPECT_TRUE(touchEventActuator->HandleEvent(touchEvent));
308 EXPECT_NE(unknownTiltX, 0);
309
310 /**
311 * @tc.steps: step5. Invoke Clear func to clear userCallback_.
312 */
313 touchEventActuator->ClearUserCallback();
314 EXPECT_EQ(touchEventActuator->userCallback_, nullptr);
315 EXPECT_TRUE(touchEventActuator->HandleEvent(touchEvent));
316 }
317
318 /**
319 * @tc.name: OnFlushTouchEventsBegin001
320 * @tc.desc: test functions OnFlushTouchEventsBegin.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(TouchEventTestNg, OnFlushTouchEventsBegin001, TestSize.Level1)
324 {
325 /**
326 * @tc.steps: step1. Create TouchEventActuator.
327 */
328 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
329
330 /**
331 * @tc.steps: step2. call OnFlushTouchEventsBegin.
332 * @tc.expected: Expected isFlushTouchEventsEnd_ The value of is false.
333 */
334 touchEventActuator->OnFlushTouchEventsBegin();
335 EXPECT_FALSE(touchEventActuator->isFlushTouchEventsEnd_);
336 }
337
338 /**
339 * @tc.name: OnFlushTouchEventsEnd001
340 * @tc.desc: test functions OnFlushTouchEventsEnd.
341 * @tc.type: FUNC
342 */
343 HWTEST_F(TouchEventTestNg, OnFlushTouchEventsEnd001, TestSize.Level1)
344 {
345 /**
346 * @tc.steps: step1. Create TouchEventActuator.
347 */
348 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
349
350 /**
351 * @tc.steps: step2. call OnFlushTouchEventsEnd.
352 * @tc.expected: Expected isFlushTouchEventsEnd_ The value of is true.
353 */
354 touchEventActuator->OnFlushTouchEventsEnd();
355 EXPECT_TRUE(touchEventActuator->isFlushTouchEventsEnd_);
356 }
357
358 /**
359 * @tc.name: ShouldResponse001
360 * @tc.desc: test functions ShouldResponse.
361 * @tc.type: FUNC
362 */
363 HWTEST_F(TouchEventTestNg, ShouldResponse001, TestSize.Level1)
364 {
365 /**
366 * @tc.steps: step1. Create TouchEventActuator.
367 */
368 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
369
370 /**
371 * @tc.steps: step2. call ShouldResponse.
372 * @tc.expected: Execute function return value is false.
373 */
374 EXPECT_TRUE(touchEventActuator->ShouldResponse());
375 }
376
377 /**
378 * @tc.name: TriggerTouchCallBack001
379 * @tc.desc: test functions TriggerTouchCallBack.
380 * @tc.type: FUNC
381 */
382 HWTEST_F(TouchEventTestNg, TriggerTouchCallBack001, TestSize.Level1)
383 {
384 /**
385 * @tc.steps: step1. Create TouchEventActuator..
386 */
387 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
388
389 /**
390 * @tc.steps: step2. create TouchEvent object and call TriggerTouchCallBack.
391 * @tc.expected: Execute function return value is true.
392 */
393 TouchEvent touchEvent;
394 touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
395 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
396
397 /**
398 * @tc.steps: step3. create TouchEventFunc object and Convert to Right Reference.
399 */
400 std::string unknownType;
__anond021ad580702(TouchEventInfo& info) 401 TouchEventFunc callback = [&unknownType](TouchEventInfo& info) { unknownType = info.GetType(); };
402 TouchEventFunc&& callback_1 = std::forward<TouchEventFunc>(callback);
403
404 /**
405 * @tc.steps: step4. commonTouchEventCallback_ assignment is not nullptr.
406 * @tc.expected: Execute function return value is true.
407 */
408 touchEventActuator->commonTouchEventCallback_ = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback_1));
409 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
410
411 /**
412 * @tc.steps: step5. onTouchEventCallback_ assignment and call TriggerTouchCallBack.
413 * @tc.expected: Execute function return value is true.
414 */
415 touchEventActuator->onTouchEventCallback_ = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback_1));
416 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
417
418 /**
419 * @tc.steps: step6. userCallback_ assignment and call TriggerTouchCallBack.
420 * @tc.expected: Execute function return value is true.
421 */
422 touchEventActuator->userCallback_ = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback_1));
423 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
424
425 /**
426 * @tc.steps: step7. isInterpolated assignment and call TriggerTouchCallBack.
427 * @tc.expected: Execute function return value is true.
428 */
429 auto touchEventImp = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback));
430 touchEventActuator->AddTouchEvent(touchEventImp);
431 touchEvent.isInterpolated = true;
432 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
433
434 /**
435 * @tc.steps: step8. create TouchEvent object and call TriggerTouchCallBack.
436 * @tc.expected: Execute function return value is true.
437 */
438 TouchEvent touchEvent_2;
439 touchEvent_2.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS_2);
440 TouchEvent touchEvent_3;
441 touchEvent_2.history.push_back(touchEvent_3);
442 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent_3));
443
444 /**
445 * @tc.steps: step9. create TouchEvent object and call isFlushTouchEventsEnd_ assignment.
446 * @tc.expected: Execute function return value is true.
447 */
448 TouchEvent touchEvent_4;
449 touchEvent_4.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS_2);
450 touchEvent_2.history.push_back(touchEvent_4);
451 touchEventActuator->isFlushTouchEventsEnd_ = true;
452 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent_2));
453 }
454
455 /**
456 * @tc.name: TouchEventTestAddClickEvent001
457 * @tc.desc: test AddClickAfterEvent and ClearClickAfterEvent.
458 * @tc.type: FUNC
459 */
460 HWTEST_F(TouchEventTestNg, TouchEventTestAddClickEvent001, TestSize.Level1)
461 {
462 /**
463 * @tc.steps: step1. Create DragEventActuator.
464 */
465 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
466 EXPECT_NE(touchEventActuator, nullptr);
467
468 /**
469 * @tc.steps: step2. Replace ClickEvent when userCallback_ is not nullptr.
470 * @tc.expected: userCallback_ will be reset and Make an new instance.
471 */
472 std::string unknownType;
__anond021ad580802(TouchEventInfo& info) 473 TouchEventFunc callback = [&unknownType](TouchEventInfo& info) { unknownType = info.GetType(); };
474 auto clickEvent = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback));
475 touchEventActuator->AddTouchAfterEvent(clickEvent);
476 EXPECT_NE(touchEventActuator->touchAfterEvents_, nullptr);
477
478 touchEventActuator->ClearTouchAfterEvent();
479 EXPECT_EQ(touchEventActuator->touchAfterEvents_, nullptr);
480 }
481
482 /**
483 * @tc.name: SetPressedKeyCodesTest001
484 * @tc.desc: SetPressedKeyCodest.
485 * @tc.type: FUNC
486 */
487 HWTEST_F(TouchEventTestNg, SetPressedKeyCodesTest001, TestSize.Level1)
488 {
489 TouchEvent touchEvent;
490 touchEvent.SetPressedKeyCodes({ KeyCode::KEY_DPAD_LEFT, KeyCode::KEY_DPAD_RIGHT });
491 EXPECT_EQ(touchEvent.pressedKeyCodes_.size(), 2);
492 EXPECT_EQ(touchEvent.pressedKeyCodes_[0], KeyCode::KEY_DPAD_LEFT);
493 }
494
495 /**
496 * @tc.name: TouchEventTest001
497 * @tc.desc: HandleEvent.
498 * @tc.type: FUNC
499 */
500 HWTEST_F(TouchEventTestNg, TouchEventTest001, TestSize.Level1)
501 {
502 TouchEvent touchEvent;
503 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
504 auto context = PipelineContext::GetCurrentContext();
505
506 auto eventManager = context->GetEventManager();
507
508 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
509 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
510 touchEventActuator->AttachFrameNode(pageNode);
511 auto ctrl = eventManager->GetResponseCtrl();
512 ctrl->state_ = ResponseCtrl::MonopolizeState::ON;
513 ctrl->firstResponseNode_.Reset();
514 EXPECT_FALSE(touchEventActuator->HandleEvent(touchEvent));
515 }
516
517 /**
518 * @tc.name: TouchEventTest002
519 * @tc.desc: TriggerTouchCallBack.
520 * @tc.type: FUNC
521 */
522 HWTEST_F(TouchEventTestNg, TouchEventTest002, TestSize.Level1)
523 {
524 TouchEvent touchEvent;
525 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
526 touchEvent.type = TouchType::DOWN;
527 touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
528 touchEventActuator->TriggerTouchCallBack(touchEvent);
529 touchEvent.type = TouchType::UP;
530 touchEventActuator->TriggerTouchCallBack(touchEvent);
531
532 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
533 }
534
535 /**
536 * @tc.name: TouchEventTest003
537 * @tc.desc: TriggerTouchCallBack.
538 * @tc.type: FUNC
539 */
540 HWTEST_F(TouchEventTestNg, TouchEventTest003, TestSize.Level1)
541 {
542 TouchEvent touchEvent;
543 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
544 touchEvent.type = TouchType::DOWN;
545 touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
546 SystemProperties::traceInputEventEnable_.store(true);
547 touchEventActuator->TriggerTouchCallBack(touchEvent);
548 touchEvent.type = TouchType::UP;
549 touchEventActuator->TriggerTouchCallBack(touchEvent);
550
551 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
552 }
553
554 /**
555 * @tc.name: TouchEventTest004
556 * @tc.desc: TriggerTouchCallBack.
557 * @tc.type: FUNC
558 */
559 HWTEST_F(TouchEventTestNg, TouchEventTest004, TestSize.Level1)
560 {
561 TouchEvent touchEvent;
562 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
563 touchEvent.type = TouchType::DOWN;
564 touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
565 touchEventActuator->TriggerTouchCallBack(touchEvent);
566 touchEvent.type = TouchType::DOWN;
567
568 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
569 }
570
571 /**
572 * @tc.name: TouchEventTest005
573 * @tc.desc: TriggerTouchCallBack.
574 * @tc.type: FUNC
575 */
576 HWTEST_F(TouchEventTestNg, TouchEventTest005, TestSize.Level1)
577 {
578 TouchEvent touchEvent;
579 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
580 touchEvent.type = TouchType::DOWN;
581 SystemProperties::traceInputEventEnable_.store(false);
582 touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
583 touchEventActuator->TriggerTouchCallBack(touchEvent);
584 touchEvent.type = TouchType::UP;
585 touchEventActuator->TriggerTouchCallBack(touchEvent);
586 touchEvent.type = TouchType::UP;
587 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
588 }
589
590 /**
591 * @tc.name: TouchEventTest006
592 * @tc.desc: TriggerTouchCallBack.
593 * @tc.type: FUNC
594 */
595 HWTEST_F(TouchEventTestNg, TouchEventTest006, TestSize.Level1)
596 {
597 TouchEvent touchEvent;
598 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
599 std::string unknownType;
__anond021ad580902(TouchEventInfo& info) 600 TouchEventFunc callback = [&unknownType](TouchEventInfo& info) { unknownType = info.GetType(); };
601 auto clickEvent = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback));
602 touchEventActuator->AddTouchAfterEvent(clickEvent);
603 TouchEventFunc&& callback_1 = std::forward<TouchEventFunc>(callback);
604 touchEventActuator->commonTouchEventCallback_ = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback_1));
605 EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
606 }
607
608 /**
609 * @tc.name: StopPass001
610 * @tc.desc: test functions SetNeedPropagation IsNeedPropagation.
611 * @tc.type: FUNC
612 */
613 HWTEST_F(TouchEventTestNg, StopPass001, TestSize.Level1)
614 {
615 /**
616 * @tc.steps: step1. Create TouchEventActuator.
617 */
618 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
619
620 /**
621 * @tc.steps: step2. call IsNeedPropagation.
622 * @tc.expected: Execute function return value is false.
623 */
624 EXPECT_FALSE(touchEventActuator->IsNeedPropagation());
625
626 /**
627 * @tc.steps: step3. call SetNeedPropagation(true).
628 * @tc.expected: Execute function return value is true.
629 */
630 touchEventActuator->SetNeedPropagation(true);
631 EXPECT_TRUE(touchEventActuator->IsNeedPropagation());
632 }
633
634 /**
635 * @tc.name: TouchEventOriginalIdTest001
636 * @tc.desc: TriggerTouchCallBack.
637 * @tc.type: FUNC
638 */
639 HWTEST_F(TouchEventTestNg, TouchEventOriginalIdTest001, TestSize.Level1)
640 {
641 TouchEvent touchEvent;
642 touchEvent.originalId = 0;
643 touchEvent.sourceType = SourceType::TOUCH;
644 touchEvent.sourceTool = SourceTool::PEN;
645 touchEvent.CovertId();
646 AceApplicationInfo::GetInstance().SetTouchPadIdChanged(true);
647 EXPECT_EQ(touchEvent.GetOriginalReCovertId(), 0);
648 AceApplicationInfo::GetInstance().SetTouchPadIdChanged(false);
649 EXPECT_EQ(touchEvent.GetOriginalReCovertId(), DEFAULT_PEN_ID);
650 AceApplicationInfo::GetInstance().SetTouchPadIdChanged(true);
651 touchEvent.originalId = DEFAULT_MOUSE_ID;
652 touchEvent.sourceType = SourceType::MOUSE;
653 EXPECT_EQ(touchEvent.GetOriginalReCovertId(), 0);
654 AceApplicationInfo::GetInstance().SetTouchPadIdChanged(false);
655 EXPECT_EQ(touchEvent.GetOriginalReCovertId(), DEFAULT_MOUSE_ID);
656 }
657
658 /**
659 * @tc.name: TouchEventOriginalIdTest002
660 * @tc.desc: TriggerTouchCallBack.
661 * @tc.type: FUNC
662 */
663 HWTEST_F(TouchEventTestNg, TouchEventOriginalIdTest002, TestSize.Level1)
664 {
665 TouchPoint touchPoint;
666 touchPoint.originalId = 0;
667 touchPoint.sourceTool = SourceTool::PEN;
668 touchPoint.CovertId();
669 AceApplicationInfo::GetInstance().SetTouchPadIdChanged(true);
670 EXPECT_EQ(touchPoint.GetOriginalReCovertId(), 0);
671 AceApplicationInfo::GetInstance().SetTouchPadIdChanged(false);
672 EXPECT_EQ(touchPoint.GetOriginalReCovertId(), DEFAULT_PEN_ID);
673 AceApplicationInfo::GetInstance().SetTouchPadIdChanged(true);
674 touchPoint.originalId = DEFAULT_MOUSE_ID;
675 touchPoint.sourceTool = SourceTool::MOUSE;
676 EXPECT_EQ(touchPoint.GetOriginalReCovertId(), 0);
677 AceApplicationInfo::GetInstance().SetTouchPadIdChanged(false);
678 EXPECT_EQ(touchPoint.GetOriginalReCovertId(), DEFAULT_MOUSE_ID);
679 }
680
681 /**
682 * @tc.name: CreateTouchItemInfoTest001
683 * @tc.desc: TriggerTouchCallBack.
684 * @tc.type: FUNC
685 */
686 HWTEST_F(TouchEventTestNg, CreateTouchItemInfoTest001, TestSize.Level1)
687 {
688 TouchEvent touchEvent;
689 touchEvent.originalId = 0;
690 touchEvent.type = TouchType::DOWN;
691 std::vector<int32_t> touchPointIds = { 0, 1 };
692 std::vector<TouchType> touchPointExpectTypes = { TouchType::DOWN, TouchType::MOVE };
693
694 for (const auto& item : touchPointIds) {
695 TouchPoint touchPoint;
696 touchPoint.originalId = item;
697 touchEvent.pointers.emplace_back(touchPoint);
698 }
699
700 std::vector<TouchType> touchesTypes;
__anond021ad580a02(TouchEventInfo& info) 701 TouchEventFunc callback = [&touchesTypes](TouchEventInfo& info) {
702 auto touches = info.GetTouches();
703 for (const auto& touch : touches) {
704 touchesTypes.emplace_back(touch.GetTouchType());
705 }
706 };
707
708 auto clickEvent = AceType::MakeRefPtr<TouchEventImpl>(std::move(callback));
709 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
710 touchEventActuator->AddTouchAfterEvent(clickEvent);
711 touchEventActuator->TriggerTouchCallBack(touchEvent);
712
713 for (int32_t i = 0; (i < touchPointExpectTypes.size()) && (i < touchesTypes.size()); i++) {
714 EXPECT_EQ(touchesTypes[i], touchPointExpectTypes[i]);
715 }
716 }
717 } // namespace OHOS::Ace::NG