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