1 /*
2 * Copyright (c) 2022-2023 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 "gtest/gtest.h"
17
18 #define private public
19 #undef SECURITY_COMPONENT_ENABLE
20
21 #include "test/mock/base/mock_drag_window.h"
22 #include "test/mock/base/mock_task_executor.h"
23 #include "test/mock/core/pipeline/mock_pipeline_context.h"
24
25 #include "base/geometry/axis.h"
26 #include "base/geometry/ng/offset_t.h"
27 #include "base/memory/ace_type.h"
28 #include "base/memory/referenced.h"
29 #include "core/components_ng/base/frame_node.h"
30 #include "core/components_ng/event/gesture_event_hub.h"
31 #include "core/components_ng/event/pan_event.h"
32 #include "core/components_ng/event/touch_event.h"
33 #include "core/components_ng/gestures/long_press_gesture.h"
34 #include "core/components_ng/gestures/pan_gesture.h"
35 #include "core/components_ng/gestures/recognizers/click_recognizer.h"
36 #include "core/components_ng/gestures/tap_gesture.h"
37 #include "core/components_ng/manager/drag_drop/drag_drop_proxy.h"
38 #include "core/components_ng/pattern/pattern.h"
39 #include "core/components_v2/inspector/inspector_constants.h"
40 #include "frameworks/core/common/event_manager.h"
41 #include "frameworks/core/components_ng/pattern/text/text_pattern.h"
42 #include "frameworks/core/components_ng/pattern/text_drag/text_drag_base.h"
43
44 using namespace testing;
45 using namespace testing::ext;
46
47 namespace OHOS::Ace::NG {
48 namespace {
49 const std::string NODE_TAG("node");
50 const OffsetF COORDINATE_OFFSET(20.0f, 20.0f);
51 constexpr int32_t TOUCH_ID = 0;
52 const Axis AXIS_VERTICAL = Axis::VERTICAL;
53 const PanDirection PAN_DIRECTION_ALL;
54 constexpr int32_t FINGERS = 1;
55 constexpr int32_t DOUBLE_FINGERS = 2;
56 constexpr int32_t CLICK_COUNTS = 2;
57 constexpr Dimension DISTANCE = 10.0_vp;
58 const std::string CHECK_TAG_1("HELLO");
59 const std::string CHECK_TAG_2("WORLD");
60 const PointF GLOBAL_POINT { 20.0f, 20.0f };
61 const PointF LOCAL_POINT { 15.0f, 15.0f };
62 RefPtr<DragWindow> MOCK_DRAG_WINDOW;
63 constexpr int32_t GESTURES_COUNTS = 2;
64 RefPtr<MockTaskExecutor> MOCK_TASK_EXECUTOR;
65 } // namespace
66
67 class GestureEventHubTestNg : public testing::Test {
68 public:
69 static void SetUpTestSuite();
70 static void TearDownTestSuite();
71 };
72
SetUpTestSuite()73 void GestureEventHubTestNg::SetUpTestSuite()
74 {
75 MockPipelineContext::SetUp();
76 MOCK_DRAG_WINDOW = DragWindow::CreateDragWindow("", 0, 0, 0, 0);
77 GTEST_LOG_(INFO) << "GestureEventHubTestNg SetUpTestCase";
78 MOCK_TASK_EXECUTOR = AceType::MakeRefPtr<MockTaskExecutor>();
79 }
80
TearDownTestSuite()81 void GestureEventHubTestNg::TearDownTestSuite()
82 {
83 MockPipelineContext::TearDown();
84 MOCK_DRAG_WINDOW = nullptr;
85 GTEST_LOG_(INFO) << "GestureEventHubTestNg TearDownTestCase";
86 }
87
88 /**
89 * @tc.name: GestureEventHubTest001
90 * @tc.desc: Create GestureEventHub and call GetFrameNode
91 * @tc.type: FUNC
92 */
93 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest001, TestSize.Level1)
94 {
95 /**
96 * @tc.steps: step1. Create GestureEventHub.
97 * @tc.expected: eventHub is not null.
98 */
99 auto eventHub = AceType::MakeRefPtr<EventHub>();
100 EXPECT_TRUE(eventHub);
101 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
102 eventHub->AttachHost(frameNode);
103 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
104 EXPECT_TRUE(gestureEventHub);
105
106 /**
107 * @tc.steps: step2. Test GetFrameNode
108 * case: eventHub is valid
109 * @tc.expected: frameNodeOfEvent is not null.
110 */
111 auto frameNodeOfEvent = gestureEventHub->GetFrameNode();
112 EXPECT_TRUE(frameNodeOfEvent);
113
114 /**
115 * @tc.steps: step2. Test GetFrameNode
116 * case: eventHub is invalid
117 * @tc.expected: frameNodeOfEvent is null.
118 */
119 eventHub = nullptr;
120 frameNode = nullptr;
121 frameNodeOfEvent = gestureEventHub->GetFrameNode();
122 EXPECT_FALSE(frameNodeOfEvent);
123 }
124
125 /**
126 * @tc.name: GestureEventHubTest002
127 * @tc.desc: Test ProcessTouchTestHit part1
128 * @tc.type: FUNC
129 */
130 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest002, TestSize.Level1)
131 {
132 /**
133 * @tc.steps: step1. Create GestureEventHub.
134 * @tc.expected: gestureEventHub is not null.
135 */
136 auto eventHub = AceType::MakeRefPtr<EventHub>();
137 EXPECT_TRUE(eventHub);
138 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
139 EXPECT_TRUE(gestureEventHub);
140
141 /**
142 * @tc.steps: step2. Test ProcessTouchTestHit
143 * case: eventHub is null && actuators such as scrollableActuator_ & touchEventActuator_ are all null
144 * @tc.expected: ProcessTouchTestHit return false, innerTargets & finalResult is empty
145 */
146 eventHub = nullptr;
147 TouchRestrict touchRestrict;
148 TouchTestResult innerTargets;
149 TouchTestResult finalResult;
150 auto flag = gestureEventHub->ProcessTouchTestHit(
151 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, PointF(), nullptr);
152 EXPECT_FALSE(flag);
153 auto sizeOfInnerTargets = static_cast<int32_t>(innerTargets.size());
154 auto sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
155 EXPECT_EQ(sizeOfInnerTargets, 0);
156 EXPECT_EQ(sizeOfFinalResult, 0);
157
158 /**
159 * @tc.steps: step3. construct touchEventActuator_
160 * then set it to gestureEventHub
161 */
162 // reconstruct a gestureEventHub
163 eventHub = AceType::MakeRefPtr<EventHub>();
164 EXPECT_TRUE(eventHub);
165 auto framenode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
166 EXPECT_NE(framenode, nullptr);
167 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
168 gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
169 EXPECT_TRUE(gestureEventHub);
170 // set touchEventActuator_
__anon94a5dfd10202(TouchEventInfo& info) 171 auto touchCallback = [](TouchEventInfo& info) {};
172 auto touchEvent = AceType::MakeRefPtr<TouchEventImpl>(std::move(touchCallback));
173 gestureEventHub->AddTouchEvent(touchEvent);
174
175 /**
176 * @tc.steps: step4. Test ProcessTouchTestHit
177 * case: eventHub is not null && touchEventActuator_ is not null
178 * @tc.expected: ProcessTouchTestHit return false, innerTargets & finalResult have one element
179 */
180 flag = gestureEventHub->ProcessTouchTestHit(
181 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, PointF(), nullptr);
182 EXPECT_FALSE(flag);
183 sizeOfInnerTargets = static_cast<int32_t>(innerTargets.size());
184 sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
185 EXPECT_EQ(sizeOfInnerTargets, 1);
186 EXPECT_EQ(sizeOfFinalResult, 1);
187 }
188
189 /**
190 * @tc.name: GestureEventHubTest003
191 * @tc.desc: Test ProcessTouchTestHit part2
192 * @tc.type: FUNC
193 */
194 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest003, TestSize.Level1)
195 {
196 /**
197 * @tc.steps: step1. Create GestureEventHub.
198 * @tc.expected: gestureEventHub is not null.
199 */
200 auto eventHub = AceType::MakeRefPtr<EventHub>();
201 EXPECT_TRUE(eventHub);
202 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
203 EXPECT_TRUE(gestureEventHub);
204
205 /**
206 * @tc.steps: step2. construct scrollableActuator_ and other actuators
207 * then set them to gestureEventHub
208 */
209
210 // set touchEventActuator_
__anon94a5dfd10302(TouchEventInfo& info) 211 auto touchCallback = [](TouchEventInfo& info) {};
212 auto touchEvent = AceType::MakeRefPtr<TouchEventImpl>(std::move(touchCallback));
213 gestureEventHub->AddTouchEvent(touchEvent);
214
215 // set scrollableActuator_
216 auto scrollableEvent = AceType::MakeRefPtr<ScrollableEvent>(AXIS_VERTICAL);
217 gestureEventHub->AddScrollableEvent(scrollableEvent);
218
219 // set clickEventActuator_
__anon94a5dfd10402(GestureEvent& info) 220 auto clickCallback = [](GestureEvent& info) {};
221 auto clickEvent = AceType::MakeRefPtr<ClickEvent>(std::move(clickCallback));
222 gestureEventHub->AddClickEvent(clickEvent);
223
224 // set panEventActuator_
__anon94a5dfd10502(GestureEvent& info) 225 auto panActionStart = [](GestureEvent& info) {};
__anon94a5dfd10602(GestureEvent& info) 226 auto panActionUpdate = [](GestureEvent& info) {};
__anon94a5dfd10702(GestureEvent& info) 227 auto panActionEnd = [](GestureEvent& info) {};
__anon94a5dfd10802() 228 auto panActionCancel = []() {};
229 auto panEvent = AceType::MakeRefPtr<PanEvent>(
230 std::move(panActionStart), std::move(panActionUpdate), std::move(panActionEnd), std::move(panActionCancel));
231 gestureEventHub->AddPanEvent(panEvent, PAN_DIRECTION_ALL, FINGERS, DISTANCE);
232
233 // set longPressEventActuator_
__anon94a5dfd10902(GestureEvent& info) 234 auto longPressCallback = [](GestureEvent& info) {};
235 auto longPressEvent = AceType::MakeRefPtr<LongPressEvent>(longPressCallback);
236 gestureEventHub->SetLongPressEvent(longPressEvent);
237
238 // set dragEventActuator_
__anon94a5dfd10a02(GestureEvent& info) 239 auto dragActionStart = [](GestureEvent& info) {};
__anon94a5dfd10b02(GestureEvent& info) 240 auto dragActionUpdate = [](GestureEvent& info) {};
__anon94a5dfd10c02(GestureEvent& info) 241 auto dragActionEnd = [](GestureEvent& info) {};
__anon94a5dfd10d02() 242 auto dragActionCancel = []() {};
243 auto dragEvent = AceType::MakeRefPtr<DragEvent>(
244 std::move(dragActionStart), std::move(dragActionUpdate), std::move(dragActionEnd), std::move(dragActionCancel));
245 gestureEventHub->SetCustomDragEvent(dragEvent, PAN_DIRECTION_ALL, FINGERS, DISTANCE);
246 }
247
248 /**
249 * @tc.name: GestureEventHubTest004
250 * @tc.desc: Test AddClickEvent, SetUserOnClick, ActClick & SetFocusClickEvent
251 * @tc.type: FUNC
252 */
253 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest004, TestSize.Level1)
254 {
255 /**
256 * @tc.steps: step1. Create GestureEventHub.
257 * @tc.expected: gestureEventHub is not null.
258 */
259 auto eventHub = AceType::MakeRefPtr<EventHub>();
260 EXPECT_TRUE(eventHub);
261 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
262 eventHub->AttachHost(frameNode);
263 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
264 EXPECT_TRUE(gestureEventHub);
265
266 /**
267 * @tc.steps: step2. call ActClick
268 * case: clickEventActuator_ is null
269 * @tc.expected: flag is false
270 */
271 auto flag = gestureEventHub->ActClick();
272 EXPECT_FALSE(flag);
273
274 /**
275 * @tc.steps: step3. call ActClick
276 * case: clickEventActuator_ is null, clickRecognizer fingers is 2, count is 1
277 * @tc.expected: flag is false
278 */
279 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, 1);
280 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
281 EXPECT_FALSE(gestureEventHub->ActClick());
282 gestureEventHub->gestureHierarchy_.clear();
283
284 /**
285 * @tc.steps: step4. call ActClick
286 * case: clickEventActuator_ is null, clickRecognizer fingers is 1, count is 1
287 * @tc.expected: flag is true
288 */
289 clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(1, 1);
__anon94a5dfd10e02(GestureEvent& info) 290 clickRecognizer->SetOnAction([](GestureEvent& info) {});
291 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
292 EXPECT_TRUE(gestureEventHub->ActClick());
293 gestureEventHub->gestureHierarchy_.clear();
294
295 /**
296 * @tc.steps: step5. construct two clickCallback
297 * one is for SetUserOnClick, the other is for AddClickEvent
298 */
299 std::string msg1;
__anon94a5dfd10f02(GestureEvent& ) 300 auto clickCallback = [&msg1](GestureEvent& /* info */) { msg1 = CHECK_TAG_1; };
301 gestureEventHub->SetUserOnClick(clickCallback);
302 std::string msg2;
__anon94a5dfd11002(GestureEvent& ) 303 auto clickCallback2 = [&msg2](GestureEvent& /* info */) { msg2 = CHECK_TAG_2; };
304 auto clickEvent = AceType::MakeRefPtr<ClickEvent>(std::move(clickCallback2));
305 gestureEventHub->AddClickEvent(clickEvent);
306
307 /**
308 * @tc.steps: step6. call ActClick
309 * case: clickEventActuator_ is not null
310 * @tc.expected: flag is true & clickCallback & clickCallback2 has be called
311 */
312 flag = gestureEventHub->ActClick();
313 EXPECT_TRUE(flag);
314 EXPECT_EQ(msg1, CHECK_TAG_1);
315 EXPECT_EQ(msg2, CHECK_TAG_2);
316
317 /**
318 * @tc.steps: step7. call eventHub's GetOrCreateFocusHub
319 * @tc.expected: return is not null
320 */
321 auto focusHub = eventHub->GetOrCreateFocusHub();
322 EXPECT_TRUE(focusHub);
323
324 /**
325 * @tc.steps: step8. call SetFocusClickEvent
326 * @tc.expected: no fatal error occur
327 */
328 msg1 = "";
__anon94a5dfd11102(GestureEvent& ) 329 auto clickCallback3 = [&msg1](GestureEvent& /* info */) { msg1 = CHECK_TAG_1; };
330 gestureEventHub->SetFocusClickEvent(clickCallback3);
331 }
332
333 /**
334 * @tc.name: GestureEventHubTest005
335 * @tc.desc: Test ActLongClick
336 * @tc.type: FUNC
337 */
338 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest005, TestSize.Level1)
339 {
340 /**
341 * @tc.steps: step1. Create GestureEventHub.
342 * @tc.expected: gestureEventHub is not null.
343 */
344 auto eventHub = AceType::MakeRefPtr<EventHub>();
345 EXPECT_TRUE(eventHub);
346 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
347 eventHub->AttachHost(frameNode);
348 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
349 EXPECT_TRUE(gestureEventHub);
350
351 /**
352 * @tc.steps: step2. call ActLongClick
353 * case: longPressEventActuator_ is null
354 * @tc.expected: flag is false
355 */
356 auto flag = gestureEventHub->ActLongClick();
357 EXPECT_FALSE(flag);
358
359 /**
360 * @tc.steps: step3. call ActLongClick
361 * case: longPressEventActuator_ is null, longPressRecognizer fingers is 2
362 * @tc.expected: flag is false
363 */
364 auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, DOUBLE_FINGERS, false);
365 gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
366 EXPECT_FALSE(gestureEventHub->ActLongClick());
367 gestureEventHub->gestureHierarchy_.clear();
368
369 /**
370 * @tc.steps: step4. call ActLongClick
371 * case: longPressEventActuator_ is null, longPressRecognizer fingers is 1
372 * @tc.expected: flag is true
373 */
374 longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, 1, false);
__anon94a5dfd11202(GestureEvent& info) 375 longPressRecognizer->SetOnAction([](GestureEvent& info) {});
376 gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
377 EXPECT_TRUE(gestureEventHub->ActLongClick());
378 gestureEventHub->gestureHierarchy_.clear();
379
380 /**
381 * @tc.steps: step5. construct a longPressCallback
382 */
383 std::string msg1;
__anon94a5dfd11302(GestureEvent& ) 384 auto longPressCallback = [&msg1](GestureEvent& /* info */) { msg1 = CHECK_TAG_1; };
385 auto longPressEvent = AceType::MakeRefPtr<LongPressEvent>(longPressCallback);
386 gestureEventHub->SetLongPressEvent(longPressEvent);
387
388 /**
389 * @tc.steps: step6. call ActLongClick
390 * case: longPressEventActuator_ is not null
391 * @tc.expected: flag is true & longPressCallback will be called
392 */
393 flag = gestureEventHub->ActLongClick();
394 EXPECT_TRUE(flag);
395 EXPECT_EQ(msg1, CHECK_TAG_1);
396
397 /**
398 * @tc.steps: step7. call eventHub's GetOrCreateFocusHub
399 * @tc.expected: return is not null
400 */
401 auto focusHub = eventHub->GetOrCreateFocusHub();
402 EXPECT_TRUE(focusHub);
403
404 /**
405 * @tc.steps: step8. call SetFocusClickEvent
406 * @tc.expected: no fatal error occur
407 */
408 msg1 = "";
__anon94a5dfd11402(GestureEvent& ) 409 auto clickCallback3 = [&msg1](GestureEvent& /* info */) { msg1 = CHECK_TAG_1; };
410 gestureEventHub->SetFocusClickEvent(clickCallback3);
411 }
412
413 /**
414 * @tc.name: GestureEventHubTest006
415 * @tc.desc: Test CombineIntoExclusiveRecognizer
416 * @tc.type: FUNC
417 */
418 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest006, TestSize.Level1)
419 {
420 /**
421 * @tc.steps: step1. Create GestureEventHub.
422 * @tc.expected: gestureEventHub is not null.
423 */
424 auto eventHub = AceType::MakeRefPtr<EventHub>();
425 EXPECT_TRUE(eventHub);
426 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
427 EXPECT_TRUE(gestureEventHub);
428
429 /**
430 * @tc.steps: step2. call CombineIntoExclusiveRecognizer
431 * case: result is empty
432 * @tc.expected: result is empty
433 */
434 TouchTestResult result;
435 gestureEventHub->CombineIntoExclusiveRecognizer(GLOBAL_POINT, LOCAL_POINT, result, TOUCH_ID);
436 auto size = static_cast<int32_t>(result.size());
437 EXPECT_EQ(size, 0);
438
439 /**
440 * @tc.steps: step3. insert element to result
441 * @tc.expected: result'size is 3
442 */
443
444 // new TouchEventActuator
445 auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();
446
447 // new LongPressRecognizer (extends NGGestureRecognizer)
448 auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(false, false);
449
450 // new ClickRecognizer (extends NGGestureRecognizer)
451 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
452
453 result.emplace_back(touchEventActuator);
454 result.emplace_back(longPressRecognizer);
455 result.emplace_back(clickRecognizer);
456 size = static_cast<int32_t>(result.size());
457 EXPECT_EQ(size, 3);
458
459 /**
460 * @tc.steps: step4. call CombineIntoExclusiveRecognizer
461 * case: recognizers'size > 1
462 * @tc.expected: result'size is 2. One is touchEventActuator, the other is a exclusiveRecognizer created by
463 * longPressRecognizer and clickRecognizer
464 */
465 gestureEventHub->CombineIntoExclusiveRecognizer(GLOBAL_POINT, LOCAL_POINT, result, TOUCH_ID);
466 size = static_cast<int32_t>(result.size());
467 EXPECT_EQ(size, 2);
468
469 /**
470 * @tc.steps: step5. call CombineIntoExclusiveRecognizer
471 * case: recognizers'size = 1
472 * @tc.expected: result2'size is 2. One is touchEventActuator, the other is longPressRecognizer
473 */
474 TouchTestResult result2;
475 result2.emplace_back(touchEventActuator);
476 result2.emplace_back(longPressRecognizer);
477 gestureEventHub->CombineIntoExclusiveRecognizer(GLOBAL_POINT, LOCAL_POINT, result2, TOUCH_ID);
478 size = static_cast<int32_t>(result2.size());
479 EXPECT_EQ(size, 2);
480 }
481
482 /**
483 * @tc.name: GestureEventHubTest007
484 * @tc.desc: Test InitDragDropEvent
485 * @tc.type: FUNC
486 */
487 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest007, TestSize.Level1)
488 {
489 /**
490 * @tc.steps: step1. Create GestureEventHub.
491 * @tc.expected: gestureEventHub is not null.
492 */
493 auto eventHub = AceType::MakeRefPtr<EventHub>();
494 EXPECT_TRUE(eventHub);
495 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
496 EXPECT_TRUE(gestureEventHub);
497
498 /**
499 * @tc.steps: step2. Call InitDragDropEvent.
500 * @tc.expected: dragEventActuator_ is not null.
501 */
502 gestureEventHub->InitDragDropEvent();
503 EXPECT_TRUE(gestureEventHub->dragEventActuator_);
504 }
505
506 /**
507 * @tc.name: GestureEventHubTest008
508 * @tc.desc: Test Functions related with drag
509 * @tc.type: FUNC
510 */
511 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest008, TestSize.Level1)
512 {
513 /**
514 * @tc.steps: step1. Create GestureEventHub.
515 * @tc.expected: gestureEventHub is not null.
516 */
517 auto eventHub = AceType::MakeRefPtr<EventHub>();
518 EXPECT_TRUE(eventHub);
519 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
520 EXPECT_TRUE(gestureEventHub);
521
522 /**
523 * @tc.steps: step2. call HandleOnDragStart
524 * case: eventHub->HasOnDragStart() is null
525 * @tc.expected: dragDropProxy_ is null.
526 */
527 GestureEvent info;
528 gestureEventHub->HandleOnDragStart(info);
529 EXPECT_FALSE(gestureEventHub->dragDropProxy_);
530
531 /**
532 * @tc.steps: step3. set OnDragStart for eventHub
533 * after that eventHub->HasOnDragStart() is not null
534 * case: dragDropInfo.customNode is not null
535 */
536 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
537 auto onDragStart = [&customNode](
__anon94a5dfd11502( const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 538 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
539 DragDropInfo dragDropInfo;
540 dragDropInfo.customNode = customNode;
541 return dragDropInfo;
542 };
543 eventHub->SetOnDragStart(std::move(onDragStart));
544
545 /**
546 * @tc.steps: step4. call HandleOnDragStart
547 * case: dragDropInfo.customNode is not null
548 * @tc.expected: dragDropProxy_ is not null.
549 */
550 gestureEventHub->HandleOnDragStart(info);
551 EXPECT_FALSE(gestureEventHub->dragDropProxy_);
552
553 /**
554 * @tc.steps: step5. set OnDragStart for eventHub2
555 * after that eventHub->HasOnDragStart() is not null
556 * case: dragDropInfo.pixelMap is not null
557 */
558 void* voidPtr = static_cast<void*>(new char[0]);
559 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
560 auto onDragStart2 = [&pixelMap](
__anon94a5dfd11602( const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 561 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
562 DragDropInfo dragDropInfo;
563 dragDropInfo.pixelMap = pixelMap;
564 return dragDropInfo;
565 };
566 auto eventHub2 = AceType::MakeRefPtr<EventHub>();
567 EXPECT_TRUE(eventHub2);
568 eventHub2->SetOnDragStart(std::move(onDragStart2));
569 auto gestureEventHub2 = AceType::MakeRefPtr<GestureEventHub>(eventHub2);
570 EXPECT_TRUE(gestureEventHub2);
571
572 /**
573 * @tc.steps: step6. call HandleOnDragStart
574 * case: dragDropInfo.pixelMap is not null
575 * @tc.expected: dragDropProxy_ is not null.
576 */
577 gestureEventHub2->HandleOnDragStart(info);
578 EXPECT_FALSE(gestureEventHub2->dragDropProxy_);
579
580 /**
581 * @tc.steps: step7. call HandleOnDragStart again
582 * case: dragDropProxy_ need to reset
583 * @tc.expected: dragDropProxy_ is not null.
584 */
585 gestureEventHub2->HandleOnDragStart(info);
586 EXPECT_FALSE(gestureEventHub2->dragDropProxy_);
587
588 /**
589 * @tc.steps: step8. call HandleOnDragUpdate
590 * @tc.expected: dragDropProxy_ is not null.
591 */
592 gestureEventHub2->HandleOnDragUpdate(info);
593 EXPECT_FALSE(gestureEventHub2->dragDropProxy_);
594
595 /**
596 * @tc.steps: step9. call HandleOnDragCancel
597 * @tc.expected: dragDropProxy_ is null.
598 */
599 gestureEventHub2->HandleOnDragCancel();
600 EXPECT_FALSE(gestureEventHub2->dragDropProxy_);
601
602 /**
603 * @tc.steps: step10. call HandleOnDragEnd
604 * case: eventHub->HasOnDrop() is false
605 * @tc.expected: dragDropProxy_ is null.
606 */
607 gestureEventHub->HandleOnDragEnd(info);
608 EXPECT_FALSE(gestureEventHub->dragDropProxy_);
609
610 /**
611 * @tc.steps: step10. call HandleOnDragEnd
612 * case: eventHub->HasOnDrop() is true
613 * @tc.expected: dragDropProxy_ is null
614 * onDrop has been called, msg1 = CHECK_TAG_1
615 */
616 std::string msg1;
__anon94a5dfd11702(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 617 auto onDrop = [&msg1](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
618 msg1 = CHECK_TAG_1;
619 };
620 eventHub->SetOnDrop(std::move(onDrop));
621 gestureEventHub->HandleOnDragStart(info);
622 gestureEventHub->HandleOnDragEnd(info);
623 EXPECT_FALSE(gestureEventHub->dragDropProxy_);
624 EXPECT_EQ(msg1, "");
625 }
626
627 /**
628 * @tc.name: GestureEventHubTest009
629 * @tc.desc: Test ModifyDone & UpdateGestureHierarchy
630 * @tc.type: FUNC
631 */
632 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest009, TestSize.Level1)
633 {
634 /**
635 * @tc.steps: step1. Create GestureEventHub.
636 * @tc.expected: gestureEventHub is not null.
637 */
638 auto eventHub = AceType::MakeRefPtr<EventHub>();
639 EXPECT_TRUE(eventHub);
640 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
641 eventHub->AttachHost(frameNode);
642 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
643 EXPECT_TRUE(gestureEventHub);
644
645 /**
646 * @tc.steps: step2. call OnModifyDone
647 * case: recreateGesture_ is true & gestures_.size() == gestureHierarchy_.size() == 0
648 * @tc.expected: recreateGesture_ = false
649 */
650 gestureEventHub->OnModifyDone();
651 EXPECT_FALSE(gestureEventHub->recreateGesture_);
652
653 /**
654 * @tc.steps: step3. call OnModifyDone
655 * case: recreateGesture_ is false
656 * @tc.expected: recreateGesture_ = false
657 */
658 gestureEventHub->OnModifyDone();
659 EXPECT_FALSE(gestureEventHub->recreateGesture_);
660
661 /**
662 * @tc.steps: step4. call OnModifyDone
663 * case: recreateGesture_ is true & gestures_.size() != gestureHierarchy_.size()
664 * @tc.expected: recreateGesture_ = false
665 * gestures_ has cleared & gestureHierarchy_ has one element
666 */
667 gestureEventHub->recreateGesture_ = true;
668 auto longPressGesture = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
669 gestureEventHub->gestures_.emplace_back(longPressGesture);
670 gestureEventHub->OnModifyDone();
671 EXPECT_FALSE(gestureEventHub->recreateGesture_);
672 auto sizeGestures = static_cast<int32_t>(gestureEventHub->gestures_.size());
673 auto sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
674 EXPECT_EQ(sizeGestures, 0);
675 EXPECT_EQ(sizeGestureHierarchy, 1);
676 }
677
678 /**
679 * @tc.name: GestureEventHubTest010
680 * @tc.desc: Test ProcessTouchTestHierarchy
681 * @tc.type: FUNC
682 */
683 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest010, TestSize.Level1)
684 {
685 /**
686 * @tc.steps: step1. Create GestureEventHub.
687 * @tc.expected: gestureEventHub is not null.
688 */
689 auto eventHub = AceType::MakeRefPtr<EventHub>();
690 EXPECT_TRUE(eventHub);
691 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
692 eventHub->AttachHost(frameNode);
693 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
694 EXPECT_TRUE(gestureEventHub);
695
696 /**
697 * @tc.steps: step2. call ProcessTouchTestHierarchy
698 * case: innerRecognizers & gestureHierarchy_ is empty, current is null
699 * @tc.expected: finalResult is empty
700 */
701 TouchRestrict touchRestrict;
702 std::list<RefPtr<NGGestureRecognizer>> innerTargets;
703 TouchTestResult finalResult;
704
705 std::vector<RefPtr<NGGestureRecognizer>> vc;
706 vc.push_back(AceType::MakeRefPtr<ClickRecognizer>());
707 auto exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(vc);
708 std::vector<RefPtr<NGGestureRecognizer>> parallelVc;
709 parallelVc.push_back(AceType::MakeRefPtr<ClickRecognizer>());
710 auto parallelRecognizer = AceType::MakeRefPtr<ParallelRecognizer>(parallelVc);
711
712 gestureEventHub->externalExclusiveRecognizer_.push_back(exclusiveRecognizer);
713 gestureEventHub->externalParallelRecognizer_.push_back(parallelRecognizer);
714 EXPECT_EQ(static_cast<int32_t>(gestureEventHub->externalExclusiveRecognizer_.size()), 1);
715 EXPECT_EQ(static_cast<int32_t>(gestureEventHub->externalParallelRecognizer_.size()), 1);
716
717 gestureEventHub->ProcessTouchTestHierarchy(
718 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, nullptr);
719 EXPECT_TRUE(finalResult.empty());
720
721 /**
722 * @tc.steps: step3. call ProcessTouchTestHierarchy several
723 * case: innerRecognizers & gestureHierarchy_ is not all empty
724 * @tc.expected: finalResult's size has increased by 1 per call
725 */
726 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Low
727 innerTargets.emplace_back(clickRecognizer);
728
729 gestureEventHub->gestureHierarchy_.emplace_back(nullptr);
730 auto clickRecognizer2 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1);
731 clickRecognizer2->SetPriorityMask(GestureMask::IgnoreInternal); // current will assigned to this
732 auto clickRecognizer3 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::High
733 clickRecognizer3->SetPriority(GesturePriority::High);
734 auto clickRecognizer4 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Parallel
735 clickRecognizer4->SetPriority(GesturePriority::Parallel);
736 auto clickRecognizer5 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Parallel
737 clickRecognizer5->SetPriority(GesturePriority::Parallel);
738
739 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
740 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer4);
741 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer2);
742 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer3);
743 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer5);
744
745 gestureEventHub->ProcessTouchTestHierarchy(
746 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, nullptr);
747 auto sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
748 EXPECT_EQ(sizeOfFinalResult, 1);
749
750 auto clickRecognizer6 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Low
751 std::list<RefPtr<NGGestureRecognizer>> innerTargets2;
752 innerTargets2.emplace_back(clickRecognizer);
753 innerTargets2.emplace_back(clickRecognizer6);
754 gestureEventHub->ProcessTouchTestHierarchy(
755 COORDINATE_OFFSET, touchRestrict, innerTargets2, finalResult, TOUCH_ID, nullptr);
756 sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
757 EXPECT_EQ(sizeOfFinalResult, 2);
758
759 std::list<RefPtr<NGGestureRecognizer>> innerTargets3;
760 innerTargets3.emplace_back(clickRecognizer);
761 innerTargets3.emplace_back(clickRecognizer6);
762 gestureEventHub->ProcessTouchTestHierarchy(
763 COORDINATE_OFFSET, touchRestrict, innerTargets3, finalResult, TOUCH_ID, nullptr);
764 sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
765 EXPECT_EQ(sizeOfFinalResult, 3);
766
767 std::list<RefPtr<NGGestureRecognizer>> innerTargets4;
768 gestureEventHub->gestureHierarchy_.clear();
769 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer4);
770 gestureEventHub->ProcessTouchTestHierarchy(
771 COORDINATE_OFFSET, touchRestrict, innerTargets4, finalResult, TOUCH_ID, nullptr);
772 sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
773 EXPECT_EQ(sizeOfFinalResult, 4);
774
775 std::list<RefPtr<NGGestureRecognizer>> innerTargets5;
776 gestureEventHub->gestureHierarchy_.clear();
777 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
778 gestureEventHub->ProcessTouchTestHierarchy(
779 COORDINATE_OFFSET, touchRestrict, innerTargets5, finalResult, TOUCH_ID, nullptr);
780 sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
781 EXPECT_EQ(sizeOfFinalResult, 5);
782 }
783
784 /**
785 * @tc.name: GestureEventHubTest011
786 * @tc.desc: Test IsAccessibilityClickable and IsAccessibiityLongClickable
787 * @tc.type: FUNC
788 */
789 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest011, TestSize.Level1)
790 {
791 /**
792 * @tc.steps: step1. Create GestureEventHub.
793 * @tc.expected: gestureEventHub is not null.
794 */
795 auto eventHub = AceType::MakeRefPtr<EventHub>();
796 ASSERT_NE(eventHub, nullptr);
797 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
798 ASSERT_NE(frameNode, nullptr);
799 eventHub->AttachHost(frameNode);
800 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
801 ASSERT_NE(gestureEventHub, nullptr);
802
803 /**
804 * @tc.steps: step2. gestureHierarchy_ has ClickRecognizer, the number of fingers is two or click count is two
805 * @tc.expected: IsAccessibilityClickable is false
806 */
807 EXPECT_FALSE(gestureEventHub->IsAccessibilityClickable());
808
809 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, 1);
810 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
811 EXPECT_FALSE(gestureEventHub->IsAccessibilityClickable());
812 gestureEventHub->gestureHierarchy_.clear();
813 clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(1, CLICK_COUNTS);
814 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
815 EXPECT_FALSE(gestureEventHub->IsAccessibilityClickable());
816 gestureEventHub->gestureHierarchy_.clear();
817
818 /**
819 * @tc.steps: step3. gestureHierarchy_ has ClickRecognizer, the number of fingers is one
820 * @tc.expected: IsAccessibilityClickable is true
821 */
822 clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1);
823 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
824 EXPECT_TRUE(gestureEventHub->IsAccessibilityClickable());
825 gestureEventHub->gestureHierarchy_.clear();
826
827 /**
828 * @tc.steps: step4. call AddClickEvent
829 * @tc.expected: IsAccessibilityClickable is true
830 */
__anon94a5dfd11802(GestureEvent& info) 831 auto clickCallback = [](GestureEvent& info) {};
832 auto clickEvent = AceType::MakeRefPtr<ClickEvent>(std::move(clickCallback));
833 gestureEventHub->AddClickEvent(clickEvent);
834 EXPECT_TRUE(gestureEventHub->IsAccessibilityClickable());
835
836 /**
837 * @tc.steps: step5. gestureHierarchy_ has LongPressRecognizer, the number of fingers is two
838 * @tc.expected: IsAccessibilityLongClickable is false
839 */
840 EXPECT_FALSE(gestureEventHub->IsAccessibilityLongClickable());
841
842 auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, DOUBLE_FINGERS, false);
843 gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
844 EXPECT_FALSE(gestureEventHub->IsAccessibilityLongClickable());
845 gestureEventHub->gestureHierarchy_.clear();
846
847 /**
848 * @tc.steps: step6. gestureHierarchy_ has LongPressRecognizer, the number of fingers is one
849 * @tc.expected: IsAccessibilityLongClickable is false
850 */
851 longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, 1, false);
852 gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
853 EXPECT_TRUE(gestureEventHub->IsAccessibilityLongClickable());
854 gestureEventHub->gestureHierarchy_.clear();
855
856 /**
857 * @tc.steps: step7. call SetLongPressEvent
858 * @tc.expected: IsAccessibilityLongClickable is true
859 */
__anon94a5dfd11902(GestureEvent& info) 860 auto longPressCallback = [](GestureEvent& info) {};
861 auto longPressEvent = AceType::MakeRefPtr<LongPressEvent>(longPressCallback);
862 gestureEventHub->SetLongPressEvent(longPressEvent);
863 EXPECT_TRUE(gestureEventHub->IsAccessibilityLongClickable());
864 }
865
866 /**
867 * @tc.name: GestureEventHubTest012
868 * @tc.desc: Test UpdateGestureHierarchy
869 * @tc.type: FUNC
870 */
871 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest012, TestSize.Level1)
872 {
873 /**
874 * @tc.steps: step1. Create GestureEventHub.
875 * @tc.expected: gestureEventHub is not null.
876 */
877 auto eventHub = AceType::MakeRefPtr<EventHub>();
878 ASSERT_NE(eventHub, nullptr);
879 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
880 ASSERT_NE(frameNode, nullptr);
881 eventHub->AttachHost(frameNode);
882 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
883 ASSERT_NE(gestureEventHub, nullptr);
884
885 /**
886 * @tc.steps: step2. call OnModifyDone
887 * @tc.expected: gestureHierarchy_ has two elements
888 */
889 gestureEventHub->recreateGesture_ = true;
890 auto tapGesture = AceType::MakeRefPtr<TapGesture>(FINGERS, 1);
891 gestureEventHub->gestures_.emplace_back(tapGesture);
892 auto longPressGesture = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
893 gestureEventHub->gestures_.emplace_back(longPressGesture);
894 auto onAccessibilityEvent = gestureEventHub->GetOnAccessibilityEventFunc();
895 ASSERT_NE(onAccessibilityEvent, nullptr);
896 onAccessibilityEvent(AccessibilityEventType::CLICK);
897 gestureEventHub->OnModifyDone();
898
899 auto sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
900 EXPECT_EQ(sizeGestureHierarchy, GESTURES_COUNTS);
901 }
902
903 /**
904 * @tc.name: GestureEventHubTest013
905 * @tc.desc: Test ProcessTouchTestHit
906 * @tc.type: FUNC
907 */
908 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest013, TestSize.Level1)
909 {
910 /**
911 * @tc.steps: step1. Create GestureEventHub.
912 * @tc.expected: gestureEventHub is not null.
913 */
914 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
915 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
916 ASSERT_NE(guestureEventHub, nullptr);
917 OffsetF coordinateOffset;
918 TouchRestrict touchRestrict;
919 TouchTestResult innerTargets;
920 TouchTestResult finalResult;
921 PointF localPoint;
922
923 PanDirection panDirection;
924 /**
925 * @tc.steps: step2. call ProcessTouchTestHit
926 * @tc.expected: result is true
927 */
928 guestureEventHub->scrollableActuator_ =
929 AceType::MakeRefPtr<ScrollableActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
930 guestureEventHub->touchEventActuator_ = AceType::MakeRefPtr<TouchEventActuator>();
931 guestureEventHub->clickEventActuator_ =
932 AceType::MakeRefPtr<ClickEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
933 guestureEventHub->panEventActuator_ = AceType::MakeRefPtr<PanEventActuator>(
934 AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
935 guestureEventHub->longPressEventActuator_ =
936 AceType::MakeRefPtr<LongPressEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
937 guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
938 AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
939 auto result = guestureEventHub->ProcessTouchTestHit(
940 coordinateOffset, touchRestrict, innerTargets, finalResult, 2, localPoint, nullptr);
941 EXPECT_FALSE(result);
942 }
943
944 /**
945 * @tc.name: GestureEventHubTest014
946 * @tc.desc: Test IsAllowedDrag
947 * @tc.type: FUNC
948 */
949 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest014, TestSize.Level1)
950 {
951 /**
952 * @tc.steps: step1. Create GestureEventHub.
953 * @tc.expected: gestureEventHub is not null.
954 */
955 auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
956 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
957 ASSERT_NE(guestureEventHub, nullptr);
958
959 auto eventHub = guestureEventHub->eventHub_.Upgrade();
960
961 auto event = guestureEventHub->eventHub_.Upgrade();
962 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
963 auto result = guestureEventHub->IsAllowedDrag(eventHub);
964 ASSERT_FALSE(result);
965 /**
966 * @tc.steps: step2. call IsAllowedDrag
967 * @tc.expected: result is correct
968 */
969 frameNode->userSet_ = true;
970 result = guestureEventHub->IsAllowedDrag(eventHub);
971 ASSERT_FALSE(result);
972
973 frameNode->userSet_ = false;
__anon94a5dfd11a02(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 974 auto func = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) { return DragDropInfo(); };
975 eventHub->onDragStart_ = func;
976 result = guestureEventHub->IsAllowedDrag(eventHub);
977 ASSERT_TRUE(result);
978
979 guestureEventHub->HandleOnDragStart(GestureEvent());
980
981 frameNode->draggable_ = true;
982 result = guestureEventHub->IsAllowedDrag(eventHub);
983 ASSERT_TRUE(result);
984
985 frameNode->draggable_ = true;
986 eventHub->onDragStart_ = nullptr;
987 result = guestureEventHub->IsAllowedDrag(eventHub);
988 ASSERT_FALSE(result);
989 }
990
991 /**
992 * @tc.name: GestureEventHubTest015
993 * @tc.desc: Test StartDragTaskForWeb HandleNotallowDrag
994 * @tc.type: FUNC
995 */
996 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest015, TestSize.Level1)
997 {
998 /**
999 * @tc.steps: step1. Create GestureEventHub.
1000 * @tc.expected: gestureEventHub is not null.
1001 */
1002 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
1003 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1004 ASSERT_NE(guestureEventHub, nullptr);
1005
1006 auto event = guestureEventHub->eventHub_.Upgrade();
1007 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1008
1009 guestureEventHub->StartDragTaskForWeb();
1010
1011 guestureEventHub->isReceivedDragGestureInfo_ = true;
1012 guestureEventHub->StartDragTaskForWeb();
1013 ASSERT_FALSE(guestureEventHub->isReceivedDragGestureInfo_);
1014
1015 guestureEventHub->HandleNotallowDrag(GestureEvent());
1016
1017 frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>());
1018 guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1019 event = guestureEventHub->eventHub_.Upgrade();
1020 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1021
1022 frameNode->userSet_ = false;
__anon94a5dfd11b02(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 1023 auto func = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) { return DragDropInfo(); };
1024 event->onDragStart_ = func;
1025 guestureEventHub->HandleOnDragStart(GestureEvent());
1026
1027 guestureEventHub->HandleNotallowDrag(GestureEvent());
1028 ASSERT_TRUE(guestureEventHub->isReceivedDragGestureInfo_);
1029 }
1030
1031 /**
1032 * @tc.name: GestureEventHubTest016
1033 * @tc.desc: Test BindMenu
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest016, TestSize.Level1)
1037 {
1038 /**
1039 * @tc.steps: step1. Create GestureEventHub.
1040 * @tc.expected: gestureEventHub is not null.
1041 */
1042 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
1043 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1044 ASSERT_NE(guestureEventHub, nullptr);
1045
1046 auto eventHub = guestureEventHub->eventHub_.Upgrade();
1047 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1048
1049 auto pipline = PipelineContext::GetCurrentContext();
__anon94a5dfd11c02(GestureEvent& info) 1050 auto func = [](GestureEvent& info) {};
1051 guestureEventHub->BindMenu(func);
1052
__anon94a5dfd11d02(GestureEvent& info) 1053 guestureEventHub->showMenu_ = AceType::MakeRefPtr<ClickEvent>([](GestureEvent& info) {});
1054 guestureEventHub->BindMenu(func);
1055
1056 guestureEventHub->clickEventActuator_ = nullptr;
1057 guestureEventHub->ClearUserOnClick();
1058 guestureEventHub->ClearUserOnTouch();
1059
1060 guestureEventHub->clickEventActuator_ =
1061 AceType::MakeRefPtr<ClickEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
1062 guestureEventHub->touchEventActuator_ = AceType::MakeRefPtr<TouchEventActuator>();
1063 guestureEventHub->ClearUserOnClick();
1064 guestureEventHub->ClearUserOnTouch();
1065 ASSERT_FALSE(guestureEventHub->clickEventActuator_->userCallback_);
1066 }
1067
1068 /**
1069 * @tc.name: GestureEventHubTest017
1070 * @tc.desc: Test ProcessTouchTestHit
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest017, TestSize.Level1)
1074 {
1075 /**
1076 * @tc.steps: step1. Create GestureEventHub.
1077 * @tc.expected: gestureEventHub is not null.
1078 */
1079 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
1080 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1081 ASSERT_NE(guestureEventHub, nullptr);
1082 OffsetF coordinateOffset;
1083 TouchRestrict touchRestrict;
1084 TouchTestResult innerTargets;
1085 TouchTestResult finalResult;
1086 PointF localPoint;
1087
1088 PanDirection panDirection;
1089 guestureEventHub->panEventActuator_ = AceType::MakeRefPtr<PanEventActuator>(
1090 AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
1091 /**
1092 * @tc.steps: step2. call ProcessTouchTestHit , recognizer is not instance of recognizer group
1093 * @tc.expected: result is false
1094 */
1095 guestureEventHub->longPressEventActuator_ =
1096 AceType::MakeRefPtr<LongPressEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
1097 guestureEventHub->dragEventActuator_ = nullptr;
1098
1099 auto result = guestureEventHub->ProcessTouchTestHit(
1100 coordinateOffset, touchRestrict, innerTargets, finalResult, 2, localPoint, nullptr);
1101 EXPECT_FALSE(result);
1102 /**
1103 * @tc.steps: step3. call ProcessTouchTestHit , recognizer is instance of recognizer group.
1104 * @tc.expected: result is false
1105 */
__anon94a5dfd11e02(GestureEvent& info) 1106 GestureEventFunc callback = [](GestureEvent& info) {};
1107 auto longPressEvent = AceType::MakeRefPtr<LongPressEvent>(std::move(callback));
1108 guestureEventHub->longPressEventActuator_->SetLongPressEvent(longPressEvent);
1109
1110 guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
1111 AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
1112
__anon94a5dfd11f02(GestureEvent& info) 1113 auto dragActionStart = [](GestureEvent& info) {};
__anon94a5dfd12002(GestureEvent& info) 1114 auto dragActionUpdate = [](GestureEvent& info) {};
__anon94a5dfd12102(GestureEvent& info) 1115 auto dragActionEnd = [](GestureEvent& info) {};
__anon94a5dfd12202() 1116 auto dragActionCancel = []() {};
1117 auto dragEvent = AceType::MakeRefPtr<DragEvent>(
1118 std::move(dragActionStart), std::move(dragActionUpdate), std::move(dragActionEnd), std::move(dragActionCancel));
1119 guestureEventHub->dragEventActuator_->userCallback_ = dragEvent;
1120 result = guestureEventHub->ProcessTouchTestHit(
1121 coordinateOffset, touchRestrict, innerTargets, finalResult, 2, localPoint, nullptr);
1122 EXPECT_FALSE(result);
1123 }
1124
1125 /**
1126 * @tc.name: GestureEventHubTest018
1127 * @tc.desc: Test HandleOnDragStart
1128 * @tc.type: FUNC
1129 */
1130 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest018, TestSize.Level1)
1131 {
1132 /**
1133 * @tc.steps: step1. create GestureEventHub.
1134 * @tc.expected: gestureEventHub is not null.
1135 */
1136 auto eventHub = AceType::MakeRefPtr<EventHub>();
1137 EXPECT_TRUE(eventHub);
1138 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1139 eventHub->AttachHost(frameNode);
1140 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1141 EXPECT_TRUE(gestureEventHub);
1142
1143 /**
1144 * @tc.steps: step2. update the input parameter attributes.
1145 */
1146 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1147 auto onDragStart = [&customNode](
__anon94a5dfd12302( const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 1148 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
1149 DragDropInfo dragDropInfo;
1150 dragDropInfo.customNode = customNode;
1151 return dragDropInfo;
1152 };
1153 eventHub->SetOnDragStart(std::move(onDragStart));
1154
1155 auto retFlag = gestureEventHub->IsAllowedDrag(eventHub);
1156 EXPECT_TRUE(retFlag);
1157
1158 auto eventManager = AceType::MakeRefPtr<EventManager>();
1159 EXPECT_TRUE(eventManager);
1160 eventManager->SetLastMoveBeforeUp(true);
1161
1162 auto pipeline = PipelineContext::GetCurrentContext();
1163 pipeline->SetEventManager(eventManager);
1164
1165 GestureEvent gestureEvent;
1166 gestureEvent.SetInputEventType(InputEventType::MOUSE_BUTTON);
1167 gestureEventHub->HandleOnDragStart(gestureEvent);
1168 EXPECT_TRUE(pipeline->GetEventManager());
1169 eventManager->SetLastMoveBeforeUp(false);
1170 gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
1171
1172 /**
1173 * @tc.steps: step3. call HandleOnDragStart with SourceType::MOUSE_BUTTON and InputEventType::TOUCH_SCREEN.
1174 * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
1175 */
1176 gestureEventHub->HandleOnDragStart(gestureEvent);
1177 EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
1178 }
1179
1180 /**
1181 * @tc.name: GestureEventHubTest0181
1182 * @tc.desc: Test HandleOnDragStart
1183 * @tc.type: FUNC
1184 */
1185 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest0181, TestSize.Level1)
1186 {
1187 /**
1188 * @tc.steps: step1. create GestureEventHub.
1189 * @tc.expected: gestureEventHub is not null.
1190 */
1191 auto eventHub = AceType::MakeRefPtr<EventHub>();
1192 EXPECT_TRUE(eventHub);
1193 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1194
1195 /**
1196 * @tc.steps: step2. update the input parameter attributes.
1197 */
1198 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1199 DragDropInfo dragDropInfo;
1200 dragDropInfo.customNode = customNode;
1201 frameNode->SetDragPreview(dragDropInfo);
1202
1203 eventHub->AttachHost(frameNode);
1204 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1205 EXPECT_TRUE(gestureEventHub);
1206
1207 auto onDragStart = [&customNode](
__anon94a5dfd12402( const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 1208 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
1209 DragDropInfo dragDropInfo;
1210 dragDropInfo.customNode = customNode;
1211 return dragDropInfo;
1212 };
1213 eventHub->SetOnDragStart(std::move(onDragStart));
1214
1215 auto eventManager = AceType::MakeRefPtr<EventManager>();
1216 EXPECT_TRUE(eventManager);
1217
1218 auto pipeline = PipelineContext::GetCurrentContext();
1219 pipeline->SetEventManager(eventManager);
1220 eventManager->SetLastMoveBeforeUp(false);
1221
1222 /**
1223 * @tc.steps: step3. call HandleOnDragStart with SourceType::MOUSE and InputEventType::TOUCH_SCREEN.
1224 * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
1225 */
1226 GestureEvent gestureEvent;
1227 gestureEvent.SetSourceDevice(SourceType::MOUSE);
1228 gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
1229 gestureEventHub->HandleOnDragStart(gestureEvent);
1230 EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
1231 }
1232
1233 /**
1234 * @tc.name: GestureEventHubTest0183
1235 * @tc.desc: Test HandleOnDragStart
1236 * @tc.type: FUNC
1237 */
1238 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest0183, TestSize.Level1)
1239 {
1240 /**
1241 * @tc.steps: step1. Create GestureEventHub.
1242 * @tc.expected: gestureEventHub is not null.
1243 */
1244 auto eventHub = AceType::MakeRefPtr<EventHub>();
1245 EXPECT_TRUE(eventHub);
1246 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXTINPUT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
1247
1248 /**
1249 * @tc.steps: step2. update the input parameter attributes.
1250 */
1251 void* voidPtr = static_cast<void*>(new char[0]);
1252 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
1253 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1254 DragDropInfo dragDropInfo;
1255 dragDropInfo.customNode = customNode;
1256 dragDropInfo.pixelMap = pixelMap;
1257 frameNode->SetDragPreview(dragDropInfo);
1258
1259 auto hostPattern = frameNode->GetPattern<TextDragBase>();
1260 EXPECT_TRUE(hostPattern);
1261
1262 eventHub->AttachHost(frameNode);
1263 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1264 EXPECT_TRUE(gestureEventHub);
1265
1266 auto onDragStart = [&customNode](
__anon94a5dfd12502( const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 1267 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
1268 DragDropInfo dragDropInfo;
1269 dragDropInfo.customNode = customNode;
1270 return dragDropInfo;
1271 };
1272 eventHub->SetOnDragStart(std::move(onDragStart));
1273
1274 auto eventManager = AceType::MakeRefPtr<EventManager>();
1275 EXPECT_TRUE(eventManager);
1276
1277 auto pipeline = PipelineContext::GetCurrentContext();
1278 pipeline->SetEventManager(eventManager);
1279 eventManager->SetLastMoveBeforeUp(false);
1280
1281 /**
1282 * @tc.steps: step3. call HandleOnDragStart with SourceType::NONE and InputEventType::TOUCH_SCREEN.
1283 * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
1284 */
1285 GestureEvent gestureEvent;
1286 gestureEvent.SetSourceDevice(SourceType::NONE);
1287 gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
1288 gestureEventHub->HandleOnDragStart(gestureEvent);
1289 EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
1290 }
1291
1292 /**
1293 * @tc.name: GestureEventHubTest0184
1294 * @tc.desc: Test HandleOnDragStart
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest0184, TestSize.Level1)
1298 {
1299 /**
1300 * @tc.steps: step1. create GestureEventHub.
1301 * @tc.expected: gestureEventHub is not null.
1302 */
1303 auto eventHub = AceType::MakeRefPtr<EventHub>();
1304 EXPECT_TRUE(eventHub);
1305 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::SEARCH_Field_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
1306
1307 /**
1308 * @tc.steps: step2. update the input parameter attributes.
1309 */
1310 DragDropInfo dragDropInfo;
1311 dragDropInfo.customNode = nullptr;
1312 dragDropInfo.pixelMap = nullptr;
1313 frameNode->SetDragPreview(dragDropInfo);
1314
1315 auto hostPattern = frameNode->GetPattern<TextDragBase>();
1316 EXPECT_TRUE(hostPattern);
1317
1318 eventHub->AttachHost(frameNode);
1319 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1320 EXPECT_TRUE(gestureEventHub);
1321
1322 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1323 auto onDragStart = [&customNode](
__anon94a5dfd12602( const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 1324 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
1325 DragDropInfo dragDropInfo;
1326 dragDropInfo.customNode = customNode;
1327 return dragDropInfo;
1328 };
1329 eventHub->SetOnDragStart(std::move(onDragStart));
1330
1331 auto eventManager = AceType::MakeRefPtr<EventManager>();
1332 EXPECT_TRUE(eventManager);
1333 auto pipeline = PipelineContext::GetCurrentContext();
1334 pipeline->SetEventManager(eventManager);
1335 eventManager->SetLastMoveBeforeUp(false);
1336
1337 /**
1338 * @tc.steps: step3. call HandleOnDragStart with SourceType::MOUSE and InputEventType::TOUCH_SCREEN.
1339 * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
1340 */
1341 GestureEvent gestureEvent;
1342 gestureEvent.SetSourceDevice(SourceType::MOUSE);
1343 gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
1344 gestureEventHub->HandleOnDragStart(gestureEvent);
1345 EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
1346 }
1347
1348 /**
1349 * @tc.name: GestureEventHubTest0185
1350 * @tc.desc: Test HandleOnDragStart
1351 * @tc.type: FUNC
1352 */
1353 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest0185, TestSize.Level1)
1354 {
1355 /**
1356 * @tc.steps: step1. Create GestureEventHub.
1357 * @tc.expected: gestureEventHub is not null.
1358 */
1359 auto eventHub = AceType::MakeRefPtr<EventHub>();
1360 EXPECT_TRUE(eventHub);
1361 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
1362
1363 /**
1364 * @tc.steps: step2. Build PixelMap and UINode, and update the properties of DragDropInfo.
1365 */
1366 void* voidPtr = static_cast<void*>(new char[0]);
1367 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
1368 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1369 DragDropInfo dragDropInfo;
1370 dragDropInfo.customNode = customNode;
1371 dragDropInfo.pixelMap = pixelMap;
1372 frameNode->SetDragPreview(dragDropInfo);
1373
1374 auto hostPattern = frameNode->GetPattern<TextDragBase>();
1375 EXPECT_TRUE(hostPattern);
1376
1377 eventHub->AttachHost(frameNode);
1378 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1379 EXPECT_TRUE(gestureEventHub);
1380
1381 auto onDragStart = [&customNode](
__anon94a5dfd12702( const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 1382 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
1383 DragDropInfo dragDropInfo;
1384 dragDropInfo.customNode = customNode;
1385 return dragDropInfo;
1386 };
1387 eventHub->SetOnDragStart(std::move(onDragStart));
1388
1389 auto eventManager = AceType::MakeRefPtr<EventManager>();
1390 EXPECT_TRUE(eventManager);
1391 auto pipeline = PipelineContext::GetCurrentContext();
1392 pipeline->SetEventManager(eventManager);
1393 eventManager->SetLastMoveBeforeUp(false);
1394
1395 /**
1396 * @tc.steps: step3. call HandleOnDragStart with SourceType::NONE and InputEventType::TOUCH_SCREEN.
1397 * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
1398 */
1399 GestureEvent gestureEvent;
1400 gestureEvent.SetSourceDevice(SourceType::NONE);
1401 gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
1402 gestureEventHub->HandleOnDragStart(gestureEvent);
1403 EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
1404 }
1405
1406 /**
1407 * @tc.name: GestureEventHubTest019
1408 * @tc.desc: Test KeyBoardShortCutClick
1409 * @tc.type: FUNC
1410 */
1411 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest019, TestSize.Level1)
1412 {
1413 /**
1414 * @tc.steps: step1. Create GestureEventHub.
1415 * @tc.expected: gestureEventHub is not null.
1416 */
1417 auto eventHub = AceType::MakeRefPtr<EventHub>();
1418 EXPECT_TRUE(eventHub);
1419 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1420 eventHub->AttachHost(frameNode);
1421 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1422 EXPECT_TRUE(gestureEventHub);
1423
1424 /**
1425 * @tc.steps: step2. construct a clickEventActuator and update gestureEventHub attributes.
1426 */
1427 auto clickEventActuator = AceType::MakeRefPtr<ClickEventActuator>(WeakPtr<NG::GestureEventHub>(gestureEventHub));
1428 gestureEventHub->clickEventActuator_ = clickEventActuator;
1429
1430 /**
1431 * @tc.steps: step3. call KeyBoardShortCutClick with event and frameNode.
1432 * @tc.expected: retFlag is false.
1433 */
1434 KeyEvent event;
1435 bool retFlag = gestureEventHub->KeyBoardShortCutClick(event, WeakPtr<NG::FrameNode>(frameNode));
1436 EXPECT_TRUE(retFlag);
1437 }
1438
1439 /**
1440 * @tc.name: GestureEventHubTest020
1441 * @tc.desc: taskScheduler of Test StartDragTaskForWeb were true branches
1442 * @tc.type: FUNC
1443 */
1444 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest020, TestSize.Level1)
1445 {
1446 /**
1447 * @tc.steps: step1. Create GestureEventHub.
1448 * @tc.expected: gestureEventHub is not null.
1449 */
1450 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
1451 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1452 ASSERT_NE(guestureEventHub, nullptr);
1453
1454 /**
1455 * @tc.steps: step2. updates event and pipeline attributes.
1456 */
1457 auto event = guestureEventHub->eventHub_.Upgrade();
1458 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1459
1460 auto pipeline = PipelineContext::GetCurrentContext();
1461 EXPECT_TRUE(pipeline);
1462
1463 /**
1464 * @tc.steps: step3. call StartDragTaskForWeb.
1465 * @tc.expected: taskScheduler is true.
1466 */
1467 guestureEventHub->isReceivedDragGestureInfo_ = true;
1468 guestureEventHub->StartDragTaskForWeb();
1469 auto taskScheduler = pipeline->GetTaskExecutor();
1470 EXPECT_FALSE(taskScheduler);
1471 }
1472
1473 /**
1474 * @tc.name: GestureEventHubTest021
1475 * @tc.desc: Test StartLongPressActionForWeb
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest021, TestSize.Level1)
1479 {
1480 /**
1481 * @tc.steps: step1. Create GestureEventHub.
1482 * @tc.expected: gestureEventHub is not null.
1483 */
1484 auto eventHub = AceType::MakeRefPtr<EventHub>();
1485 EXPECT_TRUE(eventHub);
1486 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1487 eventHub->AttachHost(frameNode);
1488 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1489 EXPECT_TRUE(gestureEventHub);
1490
1491 /**
1492 * @tc.steps: step2. construct a PipelineContext and update pipeline attributes.
1493 */
1494 auto pipeline = PipelineContext::GetCurrentContext();
1495 EXPECT_TRUE(pipeline);
1496
1497 /**
1498 * @tc.steps: step3. call StartLongPressActionForWeb.
1499 * @tc.expected: taskScheduler is false.
1500 */
1501 gestureEventHub->StartLongPressActionForWeb();
1502 auto taskScheduler = pipeline->GetTaskExecutor();
1503 EXPECT_FALSE(taskScheduler);
1504 }
1505
1506 /**
1507 * @tc.name: GestureEventHubTest022
1508 * @tc.desc: Test HandleOnDragUpdate
1509 * @tc.type: FUNC
1510 */
1511 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest022, TestSize.Level1)
1512 {
1513 /**
1514 * @tc.steps: step1. Create GestureEventHub.
1515 * @tc.expected: gestureEventHub is not null.
1516 */
1517 auto eventHub = AceType::MakeRefPtr<EventHub>();
1518 EXPECT_TRUE(eventHub);
1519 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1520 eventHub->AttachHost(frameNode);
1521 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1522 EXPECT_TRUE(gestureEventHub);
1523
1524 /**
1525 * @tc.steps: step2. construct a dragDropProxy and update gestureEventHub attributes.
1526 */
1527 constexpr int64_t PROXY_ID_NOT_FIT = 101;
1528 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
1529 gestureEventHub->dragDropProxy_ = dragDropProxy;
1530
1531 /**
1532 * @tc.steps: step3. call HandleOnDragUpdate with GestureEvent.
1533 * @tc.expected: gestureEventHub->dragDropProxy_ is true.
1534 */
1535 GestureEvent info;
1536 gestureEventHub->HandleOnDragUpdate(info);
1537 EXPECT_TRUE(gestureEventHub->dragDropProxy_);
1538
1539 /**
1540 * @tc.steps: step4. call HandleOnDragUpdate with GestureEvent.
1541 * @tc.expected: gestureEventHub->IsDragged() the return value is false.
1542 */
1543 auto pipeline = PipelineContext::GetCurrentContext();
1544 auto dragDropManager = pipeline->GetDragDropManager();
1545 dragDropManager->SetIsDragged(false);
1546 gestureEventHub->HandleOnDragUpdate(info);
1547 EXPECT_FALSE(dragDropManager->IsDragged());
1548 }
1549
1550 /**
1551 * @tc.name: GestureEventHubTest024
1552 * @tc.desc: Test HandleOnDragEnd
1553 * @tc.type: FUNC
1554 */
1555 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest024, TestSize.Level1)
1556 {
1557 /**
1558 * @tc.steps: step1. Create GestureEventHub.
1559 * @tc.expected: gestureEventHub is not null.
1560 */
1561 auto eventHub = AceType::MakeRefPtr<EventHub>();
1562 EXPECT_TRUE(eventHub);
1563 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1564 eventHub->AttachHost(frameNode);
1565
1566 /**
1567 * @tc.steps: step2. construct a func and update eventHub attributes.
1568 */
__anon94a5dfd12802(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 1569 auto func = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) { return DragDropInfo(); };
1570 eventHub->SetOnDrop(func);
1571 eventHub->customerOnDrop_ = func;
1572
1573 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1574 EXPECT_TRUE(gestureEventHub);
1575
1576 auto pipeline = PipelineContext::GetCurrentContext();
1577 pipeline->SetMinPlatformVersion(12);
1578
1579 /**
1580 * @tc.steps: step3. call HandleOnDragEnd with GestureEvent.
1581 * @tc.expected: The return value of gestureEventHub->GetFrameNode() is true.
1582 */
1583 GestureEvent info;
1584 gestureEventHub->HandleOnDragEnd(info);
1585 EXPECT_TRUE(gestureEventHub->GetFrameNode());
1586
1587 constexpr int64_t PROXY_ID_NOT_FIT = 101;
1588 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
1589 gestureEventHub->dragDropProxy_ = dragDropProxy;
1590 pipeline->SetMinPlatformVersion(9);
1591
1592 /**
1593 * @tc.steps: step4. call HandleOnDragEnd with GestureEvent.
1594 * @tc.expected: The return value of gestureEventHub->dragDropProxy_ is false.
1595 */
1596 gestureEventHub->HandleOnDragEnd(info);
1597 EXPECT_FALSE(gestureEventHub->dragDropProxy_);
1598 }
1599
1600 /**
1601 * @tc.name: GestureEventHubTest025
1602 * @tc.desc: Test HandleOnDragEnd
1603 * @tc.type: FUNC
1604 */
1605 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest025, TestSize.Level1)
1606 {
1607 /**
1608 * @tc.steps: step1. Create GestureEventHub.
1609 * @tc.expected: gestureEventHub is not null.
1610 */
1611 auto eventHub = AceType::MakeRefPtr<EventHub>();
1612 EXPECT_TRUE(eventHub);
1613 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1614 eventHub->AttachHost(frameNode);
1615
1616 /**
1617 * @tc.steps: step2. construct a func and update eventHub attributes.
1618 */
__anon94a5dfd12902(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 1619 auto func = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) { return DragDropInfo(); };
1620 eventHub->SetOnDrop(func);
1621 eventHub->customerOnDrop_ = func;
1622
1623 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1624 EXPECT_TRUE(gestureEventHub);
1625
1626 auto pipeline = PipelineContext::GetCurrentContext();
1627 pipeline->SetMinPlatformVersion(9);
1628
1629 constexpr int64_t PROXY_ID_NOT_FIT = 101;
1630 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
1631 gestureEventHub->dragDropProxy_ = dragDropProxy;
1632
1633 /**
1634 * @tc.steps: step3. call HandleOnDragEnd with GestureEvent.
1635 * @tc.expected: gestureEventHub->dragDropProxy_ is null.
1636 */
1637 GestureEvent info;
1638 gestureEventHub->HandleOnDragEnd(info);
1639 EXPECT_FALSE(gestureEventHub->dragDropProxy_);
1640
1641 eventHub->onDrop_ = nullptr;
1642 eventHub->customerOnDrop_ = nullptr;
1643 gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1644
1645 /**
1646 * @tc.steps: step4. call HandleOnDragEnd with GestureEvent.
1647 * @tc.expected: The return value of eventHub->HasOnDrop() is false.
1648 */
1649 gestureEventHub->HandleOnDragEnd(info);
1650 EXPECT_FALSE(eventHub->HasOnDrop());
1651 }
1652
1653 /**
1654 * @tc.name: GestureEventHubTest026
1655 * @tc.desc: Test HandleOnDragCancel
1656 * @tc.type: FUNC
1657 */
1658 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest026, TestSize.Level1)
1659 {
1660 /**
1661 * @tc.steps: step1. Create GestureEventHub.
1662 * @tc.expected: gestureEventHub is not null.
1663 */
1664 auto eventHub = AceType::MakeRefPtr<EventHub>();
1665 EXPECT_TRUE(eventHub);
1666 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1667 eventHub->AttachHost(frameNode);
1668 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1669 EXPECT_TRUE(gestureEventHub);
1670
1671 /**
1672 * @tc.steps: step2. construct a dragDropProxy and update gestureEventHub attribute.
1673 */
1674 constexpr int64_t PROXY_ID_NOT_FIT = 101;
1675 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
1676 gestureEventHub->dragDropProxy_ = dragDropProxy;
1677
1678 /**
1679 * @tc.steps: step3. call HandleOnDragCancel.
1680 * @tc.expected: gestureEventHub->dragDropProxy_ is null.
1681 */
1682 gestureEventHub->HandleOnDragCancel();
1683 EXPECT_FALSE(gestureEventHub->dragDropProxy_);
1684 }
1685
1686 /**
1687 * @tc.name: GestureEventHubTest027
1688 * @tc.desc: Test SetOnGestureJudgeBegin and SetOnGestureJudgeNativeBegin
1689 * @tc.type: FUNC
1690 */
1691 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest027, TestSize.Level1)
1692 {
1693 /**
1694 * @tc.steps: step1. Create GestureEventHub.
1695 * @tc.expected: gestureEventHub is not null.
1696 */
1697 auto eventHub = AceType::MakeRefPtr<EventHub>();
1698 EXPECT_TRUE(eventHub);
1699 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1700 eventHub->AttachHost(frameNode);
1701 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1702 EXPECT_TRUE(gestureEventHub);
1703
1704 /**
1705 * @tc.steps: step2. construct a gestureJudgeFunc.
1706 */
1707 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo,
__anon94a5dfd12a02(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>&) 1708 const std::shared_ptr<BaseGestureEvent>&) -> GestureJudgeResult {
1709 return GestureJudgeResult(1);
1710 };
1711
1712 /**
1713 * @tc.steps: step3. call SetOnGestureJudgeBegin with gestureJudgeFunc.
1714 * @tc.expected: gestureEventHub->gestureJudgeFunc_ is not null.
1715 */
1716 gestureEventHub->SetOnGestureJudgeBegin(gestureJudgeFunc);
1717 EXPECT_TRUE(gestureEventHub->gestureJudgeFunc_);
1718
1719 /**
1720 * @tc.steps: step4. call SetOnGestureJudgeNativeBegin with gestureJudgeFunc.
1721 * @tc.expected: gestureEventHub->gestureJudgeNativeFunc_ is not null.
1722 */
1723 gestureEventHub->SetOnGestureJudgeNativeBegin(gestureJudgeFunc);
1724 EXPECT_TRUE(gestureEventHub->gestureJudgeNativeFunc_);
1725 }
1726
1727 /**
1728 * @tc.name: GestureEventHubTest028
1729 * @tc.desc: Test IsAccessibilityClickable and IsAccessibilityLongClickable
1730 * @tc.type: FUNC
1731 */
1732 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest028, TestSize.Level1)
1733 {
1734 /**
1735 * @tc.steps: step1. Create GestureEventHub.
1736 * @tc.expected: gestureEventHub is not null.
1737 */
1738 auto eventHub = AceType::MakeRefPtr<EventHub>();
1739 EXPECT_TRUE(eventHub);
1740 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1741 eventHub->AttachHost(frameNode);
1742 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1743 EXPECT_TRUE(gestureEventHub);
1744
1745 /**
1746 * @tc.steps: step2. Updated properties for gestureEventHub.
1747 */
1748 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, FINGERS);
1749 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
1750
1751 /**
1752 * @tc.steps: step3. call IsAccessibilityClickable.
1753 * @tc.expected: retFlag is false.
1754 */
1755 bool retFlag = gestureEventHub->IsAccessibilityClickable();
1756 EXPECT_FALSE(retFlag);
1757
1758 /**
1759 * @tc.steps: step3. call IsAccessibilityLongClickable.
1760 * @tc.expected: retFlag is false.
1761 */
1762 retFlag = gestureEventHub->IsAccessibilityLongClickable();
1763 EXPECT_FALSE(retFlag);
1764 }
1765
1766 /**
1767 * @tc.name: GestureEventHubTest029
1768 * @tc.desc: Test GetHitTestModeStr
1769 * @tc.type: FUNC
1770 */
1771 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest029, TestSize.Level1)
1772 {
1773 /**
1774 * @tc.steps: step1. Create GestureEventHub.
1775 * @tc.expected: gestureEventHub is not null.
1776 */
1777 auto eventHub = AceType::MakeRefPtr<EventHub>();
1778 EXPECT_TRUE(eventHub);
1779 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1780 eventHub->AttachHost(frameNode);
1781 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1782 EXPECT_TRUE(gestureEventHub);
1783
1784 /**
1785 * @tc.steps: step2. call GetHitTestModeStr with hitTestMode_ == -1.
1786 * @tc.expected: retStr is equal to "HitTestMode.Default".
1787 */
1788 gestureEventHub->SetHitTestMode(HitTestMode(-1));
1789 std::string retStr = gestureEventHub->GetHitTestModeStr();
1790 EXPECT_EQ(retStr, "HitTestMode.Default");
1791
1792 /**
1793 * @tc.steps: step3. call GetHitTestModeStr with hitTestMode_ == 4.
1794 * @tc.expected: retStr is equal to "HitTestMode.Default".
1795 */
1796 gestureEventHub->SetHitTestMode(HitTestMode(4));
1797 retStr = gestureEventHub->GetHitTestModeStr();
1798 EXPECT_EQ(retStr, "HitTestMode.Default");
1799 }
1800
1801 /**
1802 * @tc.name: GestureEventHubTest030
1803 * @tc.desc: Test ActClick
1804 * @tc.type: FUNC
1805 */
1806 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest030, TestSize.Level1)
1807 {
1808 /**
1809 * @tc.steps: step1. Create GestureEventHub.
1810 * @tc.expected: gestureEventHub is not null.
1811 */
1812 auto eventHub = AceType::MakeRefPtr<EventHub>();
1813 EXPECT_TRUE(eventHub);
1814 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1815 eventHub->AttachHost(frameNode);
1816 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1817 EXPECT_TRUE(gestureEventHub);
1818
1819 /**
1820 * @tc.steps: step2. Updated properties for gestureEventHub.
1821 */
1822 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, CLICK_COUNTS);
1823 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
1824
1825 /**
1826 * @tc.steps: step3. call ActClick.
1827 * @tc.expected: retFlag is false.
1828 */
1829 bool retFlag = gestureEventHub->ActClick();
1830 EXPECT_FALSE(retFlag);
1831 }
1832
1833 /**
1834 * @tc.name: GestureEventHubTest031
1835 * @tc.desc: Test UpdateGestureHierarchy
1836 * @tc.type: FUNC
1837 */
1838 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest031, TestSize.Level1)
1839 {
1840 /**
1841 * @tc.steps: step1. Create GestureEventHub.
1842 * @tc.expected: gestureEventHub is not null.
1843 */
1844 auto eventHub = AceType::MakeRefPtr<EventHub>();
1845 ASSERT_NE(eventHub, nullptr);
1846 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1847 ASSERT_NE(frameNode, nullptr);
1848 eventHub->AttachHost(frameNode);
1849 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1850 ASSERT_NE(gestureEventHub, nullptr);
1851
1852 /**
1853 * @tc.steps: step2. Updated properties for gestureEventHub.
1854 */
1855 gestureEventHub->recreateGesture_ = true;
1856 auto tapGesture = AceType::MakeRefPtr<TapGesture>(FINGERS, 1);
1857 gestureEventHub->gestures_.emplace_back(tapGesture);
1858 auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, 1, false);
1859 gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
1860 gestureEventHub->UpdateGestureHierarchy();
1861
1862 /**
1863 * @tc.steps: step3. call UpdateGestureHierarchy.
1864 * @tc.expected: gestureHierarchy_ has one elements.
1865 */
1866 auto sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
1867 EXPECT_EQ(sizeGestureHierarchy, 1);
1868 }
1869
1870 /**
1871 * @tc.name: ResetDragActionForWeb001
1872 * @tc.desc: Test ResetDragActionForWeb
1873 * @tc.type: FUNC
1874 */
1875 HWTEST_F(GestureEventHubTestNg, ResetDragActionForWeb001, TestSize.Level1)
1876 {
1877 /**
1878 * @tc.steps: step1. Create GestureEventHub.
1879 * @tc.expected: gestureEventHub is not null.
1880 */
1881 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
1882 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1883 ASSERT_NE(guestureEventHub, nullptr);
1884
1885 /**
1886 * @tc.steps: step1. Calling the ResetDragActionForWeb interface
1887 * @tc.expected: IsReceivedDragGestureInfo_ Equal to false.
1888 */
1889 guestureEventHub->ResetDragActionForWeb();
1890 ASSERT_EQ(guestureEventHub->isReceivedDragGestureInfo_, false);
1891 }
1892
1893 /**
1894 * @tc.name: ResetDragActionForWeb001
1895 * @tc.desc: Test ResetDragActionForWeb
1896 * @tc.type: FUNC
1897 */
1898 HWTEST_F(GestureEventHubTestNg, OnDragStart001, TestSize.Level1)
1899 {
1900 /**
1901 * @tc.steps: step1. Create GestureEventHub.
1902 * @tc.expected: gestureEventHub is not null.
1903 */
1904 auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
1905 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1906 ASSERT_NE(guestureEventHub, nullptr);
1907 auto eventHub = guestureEventHub->eventHub_.Upgrade();
1908
1909 GestureEvent info;
1910 auto pipline = PipelineContext::GetCurrentContext();
1911
1912 auto EventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1913 EXPECT_TRUE(EventHub);
1914
1915 auto frameNodeOfEvent = EventHub->GetFrameNode();
1916 EXPECT_TRUE(frameNodeOfEvent);
1917 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
1918
1919 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1920 DragDropInfo dragDropInfo;
1921 dragDropInfo.customNode = customNode;
1922
1923 /**
1924 * @tc.steps: step1. Calling the ResetDragActionForWeb interface
1925 * @tc.expected: dragDropProxy_ Equal to false.
1926 */
1927 guestureEventHub->OnDragStart(info, pipline, frameNode, dragDropInfo, event);
1928 EXPECT_TRUE(EventHub->dragDropProxy_ == false);
1929 }
1930
1931 /**
1932 * @tc.name: GetHitTestModeStr
1933 * @tc.desc: Test GetHitTestModeStr001
1934 * @tc.type: FUNC
1935 */
1936 HWTEST_F(GestureEventHubTestNg, GetHitTestModeStr001, TestSize.Level1)
1937 {
1938 /**
1939 * @tc.steps: step1. Create GestureEventHub.
1940 * @tc.expected: gestureEventHub is not null.
1941 */
1942 auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
1943 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1944 ASSERT_NE(guestureEventHub, nullptr);
1945 auto eventHub = guestureEventHub->eventHub_.Upgrade();
1946 auto pipline = PipelineContext::GetCurrentContext();
1947 auto EventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1948 EventHub->CancelDragForWeb();
1949 string testModeStr;
1950 /**
1951 * @tc.steps: step1. Calling the GetHitTestModeStr interface
1952 * @tc.expected: EventHub ->GetHitTestModeStr() is not equal to nullptr
1953 */
1954 EXPECT_TRUE(testModeStr != EventHub->GetHitTestModeStr());
1955 }
1956
1957 /**
1958 * @tc.name: HandleOnDragUpdate001
1959 * @tc.desc: Test Functions related with drag
1960 * @tc.type: FUNC
1961 */
1962 HWTEST_F(GestureEventHubTestNg, HandleOnDragUpdate001, TestSize.Level1)
1963 {
1964 /**
1965 * @tc.steps: step1. Create guestureEventHub.
1966 * @tc.expected: gestureEventHub is not null.
1967 */
1968 auto frameNode = FrameNode::CreateFrameNode("MyButton", 102, AceType::MakeRefPtr<Pattern>());
1969 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1970 ASSERT_NE(guestureEventHub, nullptr);
1971 auto eventHub = guestureEventHub->eventHub_.Upgrade();
1972 eventHub->AttachHost(frameNode);
1973 ASSERT_NE(eventHub, nullptr);
1974
1975 auto pipline = PipelineContext::GetCurrentContext();
1976 ASSERT_NE(pipline, nullptr);
1977
1978 /**
1979 * @tc.steps: step2. call HandleOnDragStart
1980 * case: eventHub->HasOnDragStart() is null
1981 * @tc.expected: dragDropProxy_ is null.
1982 */
1983 GestureEvent info;
1984 info.SetSourceDevice(SourceType::MOUSE);
1985 guestureEventHub->HandleOnDragStart(info);
1986 EXPECT_EQ(guestureEventHub->dragDropProxy_, nullptr);
1987 /**
1988 * @tc.steps: step3. set OnDragStart for eventHub
1989 * after that eventHub->HasOnDragStart() is not null
1990 * case: dragDropInfo.customNode is not null
1991 */
1992 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
__anon94a5dfd12b02(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 1993 auto onDragStart = [&customNode](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) {
1994 DragDropInfo dragDropInfo;
1995 dragDropInfo.customNode = customNode;
1996 return dragDropInfo;
1997 };
1998 eventHub->SetOnDragStart(std::move(onDragStart));
1999
2000 /**
2001 * @tc.steps: step4. call HandleOnDragStart
2002 * case: dragDropInfo.customNode is not null
2003 * @tc.expected: dragDropProxy_ is null.
2004 */
2005 guestureEventHub->HandleOnDragStart(info);
2006 EXPECT_EQ(guestureEventHub->dragDropProxy_, nullptr);
2007
2008 /**
2009 * @tc.steps: step5. call HandleOnDragEnd
2010 * case: eventHub->HasOnDrop() is true
2011 * @tc.expected: dragDropProxy_ is null
2012 * onDrop has been called, msg1 = CHECK_TAG_1
2013 */
2014 std::string msg1;
__anon94a5dfd12c02(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 2015 auto onDrop = [&msg1](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
2016 msg1 = CHECK_TAG_1;
2017 };
2018 eventHub->SetOnDrop(std::move(onDrop));
2019 guestureEventHub->HandleOnDragStart(info);
2020 guestureEventHub->HandleOnDragEnd(info);
2021 EXPECT_EQ(guestureEventHub->dragDropProxy_, nullptr);
2022 EXPECT_EQ(msg1, "HELLO");
2023 }
2024
2025 /**
2026 * @tc.name: HandleOnDragUpdate002
2027 * @tc.desc: Test Functions related with drag
2028 * @tc.type: FUNC
2029 */
2030 HWTEST_F(GestureEventHubTestNg, HandleOnDragUpdate002, TestSize.Level1)
2031 {
2032 /**
2033 * @tc.steps: step1. create GestureEventHub.
2034 * @tc.expected: gestureEventHub is not null.
2035 */
2036 auto eventHub = AceType::MakeRefPtr<EventHub>();
2037 ASSERT_NE(eventHub, nullptr);
2038 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2039
2040 /**
2041 * @tc.steps: step2. update the input parameter attributes.
2042 */
2043 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2044 DragDropInfo dragDropInfo;
2045 dragDropInfo.customNode = customNode;
2046 frameNode->SetDragPreview(dragDropInfo);
2047
2048 eventHub->AttachHost(frameNode);
2049 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
2050 ASSERT_NE(gestureEventHub, nullptr);
2051
__anon94a5dfd12d02(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 2052 auto onDragStart = [&customNode](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) {
2053 DragDropInfo dragDropInfo;
2054 dragDropInfo.customNode = customNode;
2055 return dragDropInfo;
2056 };
2057 eventHub->SetOnDragStart(std::move(onDragStart));
2058
2059 auto eventManager = AceType::MakeRefPtr<EventManager>();
2060 ASSERT_NE(eventManager, nullptr);
2061
2062 auto pipeline = PipelineContext::GetCurrentContext();
2063 pipeline->SetEventManager(eventManager);
2064 eventManager->SetLastMoveBeforeUp(false);
2065
2066 /**
2067 * @tc.steps: step3. call HandleOnDragStart with SourceType::MOUSE and InputEventType::TOUCH_SCREEN.
2068 * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
2069 */
2070 GestureEvent gestureEvent;
2071 gestureEvent.SetSourceDevice(SourceType::MOUSE);
2072 gestureEvent.SetInputEventType(InputEventType::MOUSE_BUTTON);
2073 gestureEventHub->HandleOnDragStart(gestureEvent);
2074 EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
2075 }
2076
2077 /**
2078 * @tc.name: HandleOnDragUpdate003
2079 * @tc.desc: Test Functions related with drag
2080 * @tc.type: FUNC
2081 */
2082 HWTEST_F(GestureEventHubTestNg, HandleOnDragUpdate003, TestSize.Level1)
2083 {
2084 auto frameNode = FrameNode::CreateFrameNode(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2085 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
2086 ASSERT_NE(guestureEventHub, nullptr);
2087 auto eventHub = guestureEventHub->eventHub_.Upgrade();
2088 eventHub->AttachHost(frameNode);
2089 ASSERT_NE(eventHub, nullptr);
2090
2091 auto pipline = PipelineContext::GetCurrentContext();
2092 ASSERT_NE(pipline, nullptr);
2093
2094 pipline->SetupRootElement();
2095 pipline->onVisibleAreaChangeNodeIds_.clear();
2096 pipline->AddOnAreaChangeNode(frameNode->GetId());
2097
2098 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
__anon94a5dfd12e02(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 2099 auto onDragStart = [&customNode](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) {
2100 void* voidPtr = static_cast<void*>(new char[0]);
2101 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
2102 DragDropInfo dragDropInfo;
2103 dragDropInfo.customNode = customNode;
2104 return dragDropInfo;
2105 };
2106 eventHub->SetOnDragStart(std::move(onDragStart));
2107
2108 GestureEvent info;
2109 info.SetSourceDevice(SourceType::MOUSE);
2110 info.SetInputEventType(InputEventType::TOUCH_SCREEN);
2111 guestureEventHub->HandleOnDragStart(info);
2112 EXPECT_EQ(guestureEventHub->dragDropProxy_, nullptr);
2113 }
2114
2115 /**
2116 * @tc.name: GestureEventHubTest032
2117 * @tc.desc: Test ProcessTouchTestHierarchy
2118 * @tc.type: FUNC
2119 */
2120 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest032, TestSize.Level1)
2121 {
2122 /**
2123 * @tc.steps: step1. Create GestureEventHub.
2124 * @tc.expected: gestureEventHub is not null.
2125 */
2126 auto eventHub = AceType::MakeRefPtr<EventHub>();
2127 EXPECT_TRUE(eventHub);
2128 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
2129 EXPECT_TRUE(gestureEventHub);
2130
2131 /**
2132 * @tc.steps: step2. call ProcessTouchTestHierarchy
2133 * case: innerRecognizers & gestureHierarchy_ is empty, current is null
2134 * @tc.expected: finalResult is empty
2135 */
2136 TouchRestrict touchRestrict;
2137 std::list<RefPtr<NGGestureRecognizer>> innerTargets;
2138 TouchTestResult finalResult;
2139
2140 /**
2141 * @tc.steps: step3. call externalExclusiveRecognizer_
2142 * case: innerRecognizers & gestureHierarchy_ is empty, current is null
2143 * @tc.expected: finalResult is empty
2144 */
2145 gestureEventHub->externalExclusiveRecognizer_.push_back(nullptr);
2146 gestureEventHub->externalParallelRecognizer_.push_back(nullptr);
2147 EXPECT_EQ(static_cast<int32_t>(gestureEventHub->externalExclusiveRecognizer_.size()), 1);
2148 EXPECT_EQ(static_cast<int32_t>(gestureEventHub->externalParallelRecognizer_.size()), 1);
2149
2150 /**
2151 * @tc.steps: step4. call ProcessTouchTestHierarchy
2152 * case: innerRecognizers & gestureHierarchy_ is empty, current is null
2153 * @tc.expected: finalResult is empty
2154 */
2155 gestureEventHub->ProcessTouchTestHierarchy(
2156 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, nullptr);
2157 EXPECT_TRUE(finalResult.empty());
2158 }
2159
2160 /**
2161 * @tc.name: GetPixelMapScale001
2162 * @tc.desc: Test GetPixelMapScale
2163 * @tc.type: FUNC
2164 */
2165 HWTEST_F(GestureEventHubTestNg, GetPixelMapScale001, TestSize.Level1)
2166 {
2167 /**
2168 * @tc.steps: step1. Create GestureEventHub.
2169 * @tc.expected: gestureEventHub is not null.
2170 */
2171 auto eventHub = AceType::MakeRefPtr<EventHub>();
2172 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2173 eventHub->AttachHost(frameNode);
2174 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
2175
2176 /**
2177 * @tc.steps: step2. construct a dragDropProxy and update gestureEventHub attributes.
2178 */
2179 constexpr int64_t PROXY_ID_NOT_FIT = 101;
2180 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
2181 gestureEventHub->dragDropProxy_ = dragDropProxy;
2182
2183 /**
2184 * @tc.steps: step3. call HandleOnDragUpdate with GestureEvent.
2185 * @tc.expected: gestureEventHub->dragDropProxy_ is true.
2186 */
2187 GestureEvent info;
2188 gestureEventHub->HandleOnDragUpdate(info);
2189
2190 /**
2191 * @tc.steps: step4. call GetPixelMapScale.
2192 * @tc.expected: scale is true.
2193 */
2194 const int32_t height = 600.0f;
2195 const int32_t width = 500.0f;
2196 float scale = gestureEventHub->GetPixelMapScale(height, width);
2197 EXPECT_TRUE(scale);
2198 }
2199
2200 /**
2201 * @tc.name: IsPixelMapNeedScale001
2202 * @tc.desc: Test IsPixelMapNeedScale
2203 * @tc.type: FUNC
2204 */
2205 HWTEST_F(GestureEventHubTestNg, IsPixelMapNeedScale001, TestSize.Level1)
2206 {
2207 /**
2208 * @tc.steps: step1. Create guestureEventHub.
2209 * @tc.expected: gestureEventHub is not null.
2210 */
2211 auto frameNode = FrameNode::CreateFrameNode("mybutton", -1, AceType::MakeRefPtr<Pattern>());
2212 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
2213 ASSERT_NE(guestureEventHub, nullptr);
2214 auto eventHub = guestureEventHub->eventHub_.Upgrade();
2215 eventHub->AttachHost(frameNode);
2216 ASSERT_NE(eventHub, nullptr);
2217
2218 auto pipline = PipelineContext::GetCurrentContext();
2219 ASSERT_NE(pipline, nullptr);
2220
2221 void* voidPtr2 = static_cast<void*>(new char[0]);
2222 RefPtr<PixelMap> pixelMap2 = PixelMap::CreatePixelMap(voidPtr2);
2223 guestureEventHub->SetPixelMap(pixelMap2);
2224
2225 bool result = guestureEventHub->IsPixelMapNeedScale();
2226 EXPECT_FALSE(result);
2227 }
2228 } // namespace OHOS::Ace::NG
2229