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 "test/unittest/core/event/gesture_event_hub_test_ng.h"
17
18 #include "test/mock/base/mock_subwindow.h"
19 #include "test/mock/core/common/mock_container.h"
20 #include "test/mock/core/common/mock_interaction_interface.h"
21
22 #include "core/components_ng/base/view_abstract.h"
23 #include "core/components_ng/pattern/grid/grid_item_pattern.h"
24 #include "core/components_ng/pattern/grid/grid_pattern.h"
25 #include "core/components_ng/pattern/image/image_pattern.h"
26 #include "core/components_ng/pattern/stage/page_pattern.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS::Ace::NG {
32
33 namespace {
34 constexpr size_t DEFAULT_CHILD_COUNT = 4;
35 constexpr float GRID_WIDTH = 480.0f;
36 constexpr float GRID_HEIGHT = 800.0f;
37 constexpr float ITEM_WIDTH = 120.0f;
38 constexpr float ITEM_HEIGHT = 200.0f;
39
CreateGridNodeWithChild(size_t childCount,const GridItemStyle & gridItemStyle)40 RefPtr<FrameNode> CreateGridNodeWithChild(size_t childCount, const GridItemStyle& gridItemStyle)
41 {
42 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::GRID_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
43 []() {return AceType::MakeRefPtr<GridPattern>(); });
44 ViewAbstract::SetWidth(Referenced::RawPtr(frameNode), CalcLength(GRID_WIDTH));
45 ViewAbstract::SetHeight(Referenced::RawPtr(frameNode), CalcLength(GRID_HEIGHT));
46 std::list<RefPtr<FrameNode>> childNodes;
47
48 for (size_t i = 0; i < childCount; ++i) {
49 auto chidNodeId = ElementRegister::GetInstance()->MakeUniqueId();
50 auto childNode = FrameNode::GetOrCreateFrameNode(V2::GRID_ITEM_ETS_TAG, chidNodeId,
51 [itemStyle = gridItemStyle]() { return AceType::MakeRefPtr<GridItemPattern>(nullptr, itemStyle); });
52 ViewAbstract::SetWidth(Referenced::RawPtr(childNode), CalcLength(ITEM_WIDTH));
53 ViewAbstract::SetHeight(Referenced::RawPtr(childNode), CalcLength(ITEM_HEIGHT));
54 childNode->MountToParent(frameNode);
55 childNodes.emplace_back(childNode);
56 }
57 return frameNode;
58 }
59
ProcessDragItemGroupScene()60 RefPtr<FrameNode> ProcessDragItemGroupScene()
61 {
62 auto gridNode = CreateGridNodeWithChild(DEFAULT_CHILD_COUNT, GridItemStyle::NONE);
63 CHECK_NULL_RETURN(gridNode, nullptr);
64 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
65 CHECK_NULL_RETURN(gestureEventHub, nullptr);
66
67 for (const auto& child : gridNode->GetChildren()) {
68 auto childNode = AceType::DynamicCast<FrameNode>(child);
69 if (!childNode) {
70 continue;
71 }
72 auto gridItemPattern = childNode->GetPattern<GridItemPattern>();
73 if (!gridItemPattern) {
74 continue;
75 }
76 gridItemPattern->SetSelected(true);
77 }
78 auto gridItem = AceType::DynamicCast<FrameNode>(gridNode->GetChildByIndex(0));
79 CHECK_NULL_RETURN(gridItem, nullptr);
80 auto pattern = gridNode->GetPattern<GridPattern>();
81 CHECK_NULL_RETURN(pattern, nullptr);
82 pattern->info_.endIndex_ = DEFAULT_CHILD_COUNT;
83
84 gestureEventHub->InitDragDropEvent();
85 auto actuator = gestureEventHub->GetDragEventActuator();
86 CHECK_NULL_RETURN(actuator, nullptr);
87 actuator->isSelectedItemNode_ = true;
88 actuator->FindItemParentNode(gridItem);
89 return gridNode;
90 }
91 }
92
93 /**
94 * @tc.name: DragForbidden001
95 * @tc.desc: Test DragForbidden
96 * @tc.type: FUNC
97 */
98 HWTEST_F(GestureEventHubTestNg, DragForbidden001, TestSize.Level1)
99 {
100 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
101 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
102 ASSERT_NE(guestureEventHub, nullptr);
103 guestureEventHub->SetDragForbiddenForcely(true);
104 EXPECT_EQ(guestureEventHub->IsDragForbidden(), true);
105 guestureEventHub->SetDragForbiddenForcely(false);
106 EXPECT_EQ(guestureEventHub->IsDragForbidden(), false);
107 }
108
109 /**
110 * @tc.name: RemoveGesturesByTag002
111 * @tc.desc: Test RemoveGesturesByTag
112 * @tc.type: FUNC
113 */
114 HWTEST_F(GestureEventHubTestNg, RemoveGesturesByTag002, TestSize.Level1)
115 {
116 auto eventHub = AceType::MakeRefPtr<EventHub>();
117 auto gestureEventHub = eventHub->GetOrCreateGestureEventHub();
118 ASSERT_NE(gestureEventHub, nullptr);
119 std::vector<RefPtr<Gesture>> gestures;
120 auto longPressGestureOne = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
121 longPressGestureOne->SetTag(CHECK_TAG_1);
122 gestureEventHub->AttachGesture(longPressGestureOne);
123 auto longPressGestureTwo = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
124 gestures.emplace_back(longPressGestureTwo);
125 auto longPressGestureThree = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
126 gestures.emplace_back(longPressGestureThree);
127 auto group = AceType::MakeRefPtr<GestureGroup>(GestureMode::Exclusive, gestures);
128 gestureEventHub->AttachGesture(group);
129
130 gestureEventHub->RemoveGesturesByTag(CHECK_TAG_2);
131 EXPECT_EQ(gestureEventHub->modifierGestures_.size(), 2);
132 }
133
134 /**
135 * @tc.name: ClearJSFrameNodeOnTouch001
136 * @tc.desc: Test ClearJSFrameNodeOnTouch
137 * @tc.type: FUNC
138 */
139 HWTEST_F(GestureEventHubTestNg, ClearJSFrameNodeOnTouch001, TestSize.Level1)
140 {
141 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
142 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
143 ASSERT_NE(guestureEventHub, nullptr);
144 guestureEventHub->ClearJSFrameNodeOnTouch();
145 EXPECT_FALSE(guestureEventHub->touchEventActuator_);
146 }
147
148 /**
149 * @tc.name: SetDragGatherPixelMaps003
150 * @tc.desc: Test SetDragGatherPixelMaps when input type is not mouse button.
151 * @tc.type: FUNC
152 */
153 HWTEST_F(GestureEventHubTestNg, SetDragGatherPixelMaps003, TestSize.Level1)
154 {
155 auto gridNode = ProcessDragItemGroupScene();
156 ASSERT_NE(gridNode, nullptr);
157 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
158 ASSERT_NE(gestureEventHub, nullptr);
159
160 auto context = PipelineContext::GetCurrentContext();
161 ASSERT_NE(context, nullptr);
162 auto dragDropManager = context->GetDragDropManager();
163 ASSERT_NE(dragDropManager, nullptr);
164 auto overlayManager = context->GetOverlayManager();
165 ASSERT_NE(overlayManager, nullptr);
166 auto imageNode = FrameNode::CreateFrameNode(V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
167 AceType::MakeRefPtr<ImagePattern>());
168 ASSERT_NE(imageNode, nullptr);
169 GatherNodeChildInfo gatherNodeChildInfo;
170 gatherNodeChildInfo.imageNode = imageNode;
171 GatherNodeChildInfo gatherNodeChildInfo1;
172 gatherNodeChildInfo1.imageNode = imageNode;
173 std::vector<GatherNodeChildInfo> gatherNodeChildInfos;
174 gatherNodeChildInfos.emplace_back(gatherNodeChildInfo);
175 gatherNodeChildInfos.emplace_back(gatherNodeChildInfo1);
176 ASSERT_NE(gestureEventHub->GetFrameNode(), nullptr);
177 overlayManager->MountGatherNodeToRootNode(gestureEventHub->GetFrameNode(), gatherNodeChildInfos);
178
179 GestureEvent info;
180 info.SetInputEventType(InputEventType::TOUCH_SCREEN);
181 gestureEventHub->SetDragGatherPixelMaps(info);
182 EXPECT_TRUE(dragDropManager->gatherPixelMaps_.empty());
183 }
184
185 /**
186 * @tc.name: GetUnifiedData003
187 * @tc.desc: Test GetUnifiedData function.
188 * @tc.type: FUNC
189 */
190 HWTEST_F(GestureEventHubTestNg, GetUnifiedData003, TestSize.Level1)
191 {
192 auto eventHub = AceType::MakeRefPtr<EventHub>();
193 EXPECT_TRUE(eventHub);
194 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
195 EXPECT_TRUE(gestureEventHub);
196
197 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
__anon2dbee2e90402(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 198 auto defaultOnDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
199 DragDropInfo dragDropInfo;
200 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
201 dragEvent->SetData(unifiedData);
202 dragDropInfo.extraInfo = "default extraInfo";
203 return dragDropInfo;
204 };
205 eventHub->SetDefaultOnDragStart(std::move(defaultOnDragStart));
206 EXPECT_TRUE(eventHub->GetDefaultOnDragStart());
207
208 DragDropInfo dragDropInfo;
209 dragDropInfo.extraInfo.append("name");
210 gestureEventHub->GetUnifiedData("", dragDropInfo, dragEvent);
211 EXPECT_TRUE(dragEvent->GetData());
212 EXPECT_EQ(dragDropInfo.extraInfo, "name");
213
214 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
215 dragEvent->SetData(unifiedData);
216 dragDropInfo.extraInfo = "user set extraInfo";
217 eventHub->SetDefaultOnDragStart(std::move(defaultOnDragStart));
218 EXPECT_TRUE(eventHub->GetDefaultOnDragStart());
219 PanDirection panDirection;
220 gestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(nullptr, panDirection, 0, 0.0f);
221 gestureEventHub->dragEventActuator_->SetIsDefaultOnDragStartExecuted(false);
222 gestureEventHub->GetUnifiedData("TextArea", dragDropInfo, dragEvent);
223 EXPECT_TRUE(dragEvent->GetData());
224 EXPECT_EQ(dragDropInfo.extraInfo, "user set extraInfo");
225 DragDropInfo dragDropInfo1;
226 gestureEventHub->GetUnifiedData("TextArea", dragDropInfo1, dragEvent);
227 EXPECT_TRUE(dragEvent->GetData());
228 EXPECT_EQ(dragDropInfo1.extraInfo, "");
229 gestureEventHub->dragEventActuator_->SetIsDefaultOnDragStartExecuted(true);
230 gestureEventHub->GetUnifiedData("TextArea", dragDropInfo1, dragEvent);
231 EXPECT_TRUE(dragEvent->GetData());
232 EXPECT_EQ(dragDropInfo1.extraInfo, "");
233 }
234
235 /**
236 * @tc.name: GestureEventHubGetPixelMapOffset002
237 * @tc.desc: Test GetPixelMapOffset
238 * @tc.type: FUNC
239 */
240 HWTEST_F(GestureEventHubTestNg, GestureEventHubGetPixelMapOffset002, TestSize.Level1)
241 {
242 auto frameNode1 = FrameNode::CreateFrameNode("MyButton", 102, AceType::MakeRefPtr<Pattern>());
243 auto gestureEventHub = frameNode1->GetOrCreateGestureEventHub();
244 ASSERT_NE(gestureEventHub, nullptr);
245 auto eventHub = gestureEventHub->eventHub_.Upgrade();
246 eventHub->AttachHost(frameNode1);
247 ASSERT_NE(eventHub, nullptr);
248
249 constexpr float PIXELMAP_WIDTH_RATE = -0.5f;
250 constexpr float PIXELMAP_HEIGHT_RATE = -0.2f;
251 GestureEvent info = GestureEvent();
252 auto size = SizeF(1, 1);
253 gestureEventHub->frameNodeOffset_.SetX(1);
254 gestureEventHub->frameNodeOffset_.SetY(1);
255 PreparedInfoForDrag data;
256 gestureEventHub->GetPixelMapOffset(info, size, data, -1.0f);
257 auto frameNode2 = gestureEventHub->GetFrameNode();
258 EXPECT_NE(frameNode2, nullptr);
259 OffsetF result = OffsetF(size.Width() * PIXELMAP_WIDTH_RATE, size.Height() * PIXELMAP_HEIGHT_RATE);
260 EXPECT_FALSE(NearZero(size.Width()));
261 EXPECT_FALSE(result.GetX() >= 0.0f);
262 EXPECT_FALSE(result.GetX() + size.Width() <= 0.0f);
263 EXPECT_FALSE(result.GetY() >= 0.0f);
264 EXPECT_FALSE(result.GetY() + size.Height() <= 0.0f);
265 }
266
267 /**
268 * @tc.name: GestureEventHubGetPixelMapOffset003
269 * @tc.desc: Test GetPixelMapOffset
270 * @tc.type: FUNC
271 */
272 HWTEST_F(GestureEventHubTestNg, GestureEventHubGetPixelMapOffset003, TestSize.Level1)
273 {
274 auto frameNodeTest = FrameNode::CreateFrameNode("MyButton", 102, AceType::MakeRefPtr<Pattern>());
275 auto gestureEventHub = frameNodeTest->GetOrCreateGestureEventHub();
276 ASSERT_NE(gestureEventHub, nullptr);
277 auto eventHub = gestureEventHub->eventHub_.Upgrade();
278 eventHub->AttachHost(frameNodeTest);
279 ASSERT_NE(eventHub, nullptr);
280
281 constexpr float PIXELMAP_WIDTH_RATE = -0.5f;
282 constexpr float PIXELMAP_HEIGHT_RATE = -0.2f;
283 GestureEvent info = GestureEvent();
284 auto size = SizeF(1, 1);
285 gestureEventHub->frameNodeOffset_.SetX(1);
286 gestureEventHub->frameNodeOffset_.SetY(1);
287 PreparedInfoForDrag data;
288 data.isNeedCreateTiled = true;
289 gestureEventHub->GetPixelMapOffset(info, size, data, -1.0f);
290 auto frameNode = gestureEventHub->GetFrameNode();
291 EXPECT_NE(frameNode, nullptr);
292 OffsetF result = OffsetF(size.Width() * PIXELMAP_WIDTH_RATE, size.Height() * PIXELMAP_HEIGHT_RATE);
293 EXPECT_FALSE(result.GetX() + size.Width() <= 0.0f);
294 EXPECT_FALSE(result.GetY() + size.Height() <= 0.0f);
295 }
296
297 /**
298 * @tc.name: MonopolizeEvents001
299 * @tc.desc: Test MonopolizeEvents
300 * @tc.type: FUNC
301 */
302 HWTEST_F(GestureEventHubTestNg, MonopolizeEvents001, TestSize.Level1)
303 {
304 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
305 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
306 ASSERT_NE(guestureEventHub, nullptr);
307 guestureEventHub->SetMonopolizeEvents(true);
308 EXPECT_EQ(guestureEventHub->GetMonopolizeEvents(), true);
309 guestureEventHub->SetMonopolizeEvents(false);
310 EXPECT_EQ(guestureEventHub->GetMonopolizeEvents(), false);
311 }
312
313 /**
314 * @tc.name: OnTouchInterceptFunc001
315 * @tc.desc: Test Set and Get OnTouchIntercept function
316 * @tc.type: FUNC
317 */
318 HWTEST_F(GestureEventHubTestNg, OnTouchInterceptFunc001, TestSize.Level1)
319 {
320 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
321 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
322 ASSERT_NE(guestureEventHub, nullptr);
__anon2dbee2e90502(TouchEventInfo& info) 323 auto onTouchInterceptfunc = [](TouchEventInfo& info) -> NG::HitTestMode { return NG::HitTestMode::HTMTRANSPARENT; };
324 guestureEventHub->SetOnTouchIntercept(std::move(onTouchInterceptfunc));
325 auto onGetTouchInterceptfunc = guestureEventHub->GetOnTouchIntercept();
326 ASSERT_NE(onGetTouchInterceptfunc, nullptr);
327 OHOS::Ace::TouchEventInfo info("unknown");
328 auto funcRet = onGetTouchInterceptfunc(info);
329 EXPECT_EQ(funcRet, NG::HitTestMode::HTMTRANSPARENT);
330 }
331
332 /**
333 * @tc.name: GestureRecognizerJudgeFunc001
334 * @tc.desc: Test Set and Get GestureRecognizerJudgeFunc function
335 * @tc.type: FUNC
336 */
337 HWTEST_F(GestureEventHubTestNg, GestureRecognizerJudgeFunc001, TestSize.Level1)
338 {
339 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
340 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
341 ASSERT_NE(guestureEventHub, nullptr);
342 auto func = [](const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current,
__anon2dbee2e90602(const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current, const std::list<RefPtr<NGGestureRecognizer>>& others) 343 const std::list<RefPtr<NGGestureRecognizer>>& others) { return GestureJudgeResult(); };
344
345 guestureEventHub->SetOnGestureRecognizerJudgeBegin(std::move(func));
346 EXPECT_NE(guestureEventHub->GetOnGestureRecognizerJudgeBegin(), nullptr);
347 }
348
349 /**
350 * @tc.name: SetDragData001
351 * @tc.desc: Test SetDragData function when user has not set the onDragStart callback.
352 * @tc.type: FUNC
353 */
354 HWTEST_F(GestureEventHubTestNg, SetDragData001, TestSize.Level1)
355 {
356 /**
357 * @tc.steps: step1. Create GestureEventHub.
358 * @tc.expected: gestureEventHub is not null.
359 */
360 auto eventHub = AceType::MakeRefPtr<EventHub>();
361 EXPECT_TRUE(eventHub);
362 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
363 EXPECT_TRUE(gestureEventHub);
364
365 /**
366 * @tc.steps: step2. set OnDragStart for eventHub
367 * case: user not set onDragStart callback function
368 */
369 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
__anon2dbee2e90702(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 370 auto defaultOnDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
371 DragDropInfo dragDropInfo;
372 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
373 dragEvent->SetData(unifiedData);
374 dragDropInfo.extraInfo = "default extraInfo";
375 return dragDropInfo;
376 };
377 eventHub->SetDefaultOnDragStart(std::move(defaultOnDragStart));
378 EXPECT_TRUE(eventHub->GetDefaultOnDragStart());
379
380 /**
381 * @tc.steps: step3. Call GetUnifiedData function
382 * case: Do not set default onDragStart function
383 * @tc.expected: unifiedData is not null, extraInfo is not empty.
384 */
385 DragDropInfo dragDropInfo;
386 auto unifiedData = gestureEventHub->GetUnifiedData("", dragDropInfo, dragEvent);
387 EXPECT_TRUE(dragEvent->GetData());
388 EXPECT_EQ(dragDropInfo.extraInfo, "default extraInfo");
389
390 auto newUnifiedData = AceType::MakeRefPtr<MockUnifiedData>();
391 ASSERT_NE(newUnifiedData, nullptr);
392 std::string udKey;
393 auto ret = gestureEventHub->SetDragData(newUnifiedData, udKey);
394 EXPECT_NE(ret, -1);
395 }
396 /**
397 * @tc.name: SetMouseDragMonitorState
398 * @tc.desc: Test SetMouseDragMonitorState function
399 * @tc.type: FUNC
400 */
401 HWTEST_F(GestureEventHubTestNg, SetMouseDragMonitorState001, TestSize.Level1)
402 {
403 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
404 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
405 ASSERT_NE(guestureEventHub, nullptr);
406 guestureEventHub->SetMouseDragMonitorState(true);
407
408 NG::ShouldBuiltInRecognizerParallelWithFunc shouldBuiltInRecognizerParallelWithFunc;
409 guestureEventHub->SetShouldBuildinRecognizerParallelWithFunc(std::move(shouldBuiltInRecognizerParallelWithFunc));
410 guestureEventHub->GetParallelInnerGestureToFunc();
411 }
412
413 /**
414 * @tc.name: AccessibilityRecursionSearchRecognizer
415 * @tc.desc: Test AccessibilityRecursionSearchRecognizer group function
416 * @tc.type: FUNC
417 */
418 HWTEST_F(GestureEventHubTestNg, AccessibilityRecursionSearchRecognizer001, TestSize.Level1)
419 {
420 auto eventHub = AceType::MakeRefPtr<EventHub>();
421 ASSERT_NE(eventHub, nullptr);
422 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
423 ASSERT_NE(frameNode, nullptr);
424 eventHub->AttachHost(frameNode);
425 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
426 ASSERT_NE(gestureEventHub, nullptr);
427
428 auto clickRecognizer1 = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, 1);
429 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer1);
430 auto clickRecognizer2 = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, 2);
431 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer2);
432 auto clickRecognizer3 = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, 3);
433 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer3);
434
435 gestureEventHub->IsAccessibilityClickable();
436 EXPECT_EQ(gestureEventHub->gestureHierarchy_.size(), 3);
437 gestureEventHub->gestureHierarchy_.clear();
438 }
439
InitFrameNodes(const std::string & tag)440 std::pair<RefPtr<FrameNode>, RefPtr<FrameNode>> InitFrameNodes(const std::string& tag)
441 {
442 auto rootNode = FrameNode::CreateFrameNode(tag, ElementRegister::GetInstance()->MakeUniqueId(),
443 AceType::MakeRefPtr<Pattern>());
444 rootNode->GetOrCreateFocusHub();
445 auto columnNode = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
446 AceType::MakeRefPtr<LinearLayoutPattern>(true));
447 auto childImageNode = FrameNode::CreateFrameNode(V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
448 AceType::MakeRefPtr<ImagePattern>());
449 auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
450 geometryNode->SetFrameSize(SizeF(1.0f, 2.0f));
451 childImageNode->SetGeometryNode(geometryNode);
452 columnNode->AddChild(childImageNode);
453 return std::make_pair(rootNode, columnNode);
454 }
455 /**
456 * @tc.name: OnDragStart002
457 * @tc.desc: Test DragPreviewOption
458 * @tc.type: FUNC
459 */
460 HWTEST_F(GestureEventHubTestNg, OnDragStart002, TestSize.Level1)
461 {
462 /**
463 * @tc.steps: step1. create webFrameNode and overlayManager
464 */
465 auto [webFrameNode, columnNode] = InitFrameNodes(V2::WEB_ETS_TAG);
466 auto pipline = PipelineContext::GetMainPipelineContext();
467 auto overlayManager = pipline->GetOverlayManager();
468 ASSERT_NE(overlayManager, nullptr);
469 pipline->SetupRootElement();
470 webFrameNode->GetOrCreateFocusHub();
471 overlayManager->SetIsMenuShow(true);
472 /**
473 * @tc.steps: step2. create columnNode and image node
474 */
475 overlayManager->pixmapColumnNodeWeak_ = AceType::WeakClaim(AceType::RawPtr(columnNode));
476 auto gestureHub = webFrameNode->GetOrCreateGestureEventHub();
477 gestureHub->InitDragDropEvent();
478 overlayManager->MountPixelMapToRootNode(columnNode);
479 overlayManager->isMenuShow_ = true;
480 /**
481 * @tc.steps: step3. mock pixelmap and subwindow
482 */
483 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
484 ASSERT_NE(pixelMap, nullptr);
485 EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(testing::Return(4.0f));
486 EXPECT_CALL(*pixelMap, GetHeight()).WillRepeatedly(testing::Return(5.0f));
487 gestureHub->SetPixelMap(pixelMap);
488
489 auto containerId = Container::CurrentId();
490 auto subwindow = AceType::MakeRefPtr<MockSubwindow>();
491 SubwindowManager::GetInstance()->AddSubwindow(containerId, subwindow);
492 MockContainer::SetUp();
493 MockContainer::Current();
494 /**
495 * @tc.steps: step4. create OnDragStart params
496 */
497 GestureEvent info;
498 auto dragDropManager = pipline->GetDragDropManager();
499 ASSERT_NE(dragDropManager, nullptr);
500 dragDropManager->SetIsDragWithContextMenu(true);
501 dragDropManager->PushGatherPixelMap(pixelMap);
502 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
503 DragDropInfo dragDropInfo = {customNode, pixelMap};
504 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
505 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
506 event->SetData(unifiedData);
507 NG::DragPreviewOption option { true, false, true, true};
508 webFrameNode->SetDragPreviewOptions(option);
509 gestureHub->dragEventActuator_->preScaledPixelMap_ = pixelMap;
510 /**
511 * @tc.steps: step5. call OnDragStart
512 */
513 gestureHub->OnDragStart(info, pipline, webFrameNode, dragDropInfo, event);
514 EXPECT_NE(gestureHub->pixelMap_, nullptr);
515 EXPECT_NE(gestureHub->dragEventActuator_, nullptr);
516 EXPECT_NE(gestureHub->GetPreScaledPixelMapIfExist(1.0f, pixelMap), nullptr);
517 SubwindowManager::GetInstance()->subwindowMap_.clear();
518 MockContainer::TearDown();
519 }
520
521 /**
522 * @tc.name: OnDragStart003
523 * @tc.desc: Test DragPreviewOption
524 * @tc.type: FUNC
525 */
526 HWTEST_F(GestureEventHubTestNg, OnDragStart003, TestSize.Level1)
527 {
528 /**
529 * @tc.steps: step1. create webFrameNode and overlayManager
530 */
531 auto [buttonFrameNode, columnNode] = InitFrameNodes("myButton");
532 auto pipline = PipelineContext::GetMainPipelineContext();
533 auto overlayManager = pipline->GetOverlayManager();
534 ASSERT_NE(overlayManager, nullptr);
535 pipline->SetupRootElement();
536 buttonFrameNode->GetOrCreateFocusHub();
537 overlayManager->SetIsMenuShow(true);
538 /**
539 * @tc.steps: step2. init overlayManager infos
540 */
541 overlayManager->pixmapColumnNodeWeak_ = AceType::WeakClaim(AceType::RawPtr(columnNode));
542 auto gestureHub = buttonFrameNode->GetOrCreateGestureEventHub();
543 SystemProperties::dragDropFrameworkStatus_ = 3;
544 gestureHub->InitDragDropEvent();
545 overlayManager->MountPixelMapToRootNode(columnNode);
546 overlayManager->isMenuShow_ = true;
547 /**
548 * @tc.steps: step3. mock pixelmap and subwindow
549 */
550 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
551 ASSERT_NE(pixelMap, nullptr);
552 EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(testing::Return(256.0f));
553 EXPECT_CALL(*pixelMap, GetHeight()).WillRepeatedly(testing::Return(2.0f));
554 gestureHub->SetPixelMap(pixelMap);
555 auto containerId = Container::CurrentId();
556 auto subwindow = AceType::MakeRefPtr<MockSubwindow>();
557 SubwindowManager::GetInstance()->AddSubwindow(containerId, subwindow);
558 EXPECT_CALL(*subwindow, ShowPreviewNG(false)).WillRepeatedly(testing::Return(true));
559 EXPECT_CALL(*subwindow, GetOverlayManager()).WillRepeatedly(testing::Return(overlayManager));
560 MockContainer::SetUp();
561 MockContainer::Current();
562 /**
563 * @tc.steps: step4. create OnDragStart params
564 */
565 GestureEvent info;
566 auto dragDropManager = pipline->GetDragDropManager();
567 ASSERT_NE(dragDropManager, nullptr);
568 dragDropManager->SetIsDragWithContextMenu(true);
569 dragDropManager->PushGatherPixelMap(pixelMap);
570 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
571 DragDropInfo dragDropInfo = {customNode, pixelMap};
572 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
573 NG::DragPreviewOption option { true, false, true, true};
574 option.badgeNumber = 4;
575 buttonFrameNode->SetDragPreviewOptions(option);
576 gestureHub->dragEventActuator_->preScaledPixelMap_ = pixelMap;
577
578 GestureEvent infoEvent = GestureEvent();
579 gestureHub->dragEventActuator_->userCallback_->actionEnd_(infoEvent);
580 gestureHub->dragEventActuator_->userCallback_->actionStart_(infoEvent);
581 gestureHub->dragEventActuator_->userCallback_->actionCancel_();
582 gestureHub->dragEventActuator_->userCallback_->actionUpdate_(infoEvent);
583 /**
584 * @tc.steps: step5. call OnDragStart
585 */
586 gestureHub->OnDragStart(info, pipline, buttonFrameNode, dragDropInfo, event);
587 ASSERT_NE(gestureHub->pixelMap_, nullptr);
588 ASSERT_NE(gestureHub->dragEventActuator_, nullptr);
589 EXPECT_NE(gestureHub->GetPreScaledPixelMapIfExist(1.0f, pixelMap), nullptr);
590 SubwindowManager::GetInstance()->subwindowMap_.clear();
591 MockContainer::TearDown();
592 }
593
594 /**
595 * @tc.name: OnDragStart004
596 * @tc.desc: Test DragStart
597 * @tc.type: FUNC
598 */
599 HWTEST_F(GestureEventHubTestNg, OnDragStart004, TestSize.Level1)
600 {
601 /**
602 * @tc.steps: step1. create webFrameNode and overlayManager
603 */
604 auto [buttonFrameNode, columnNode] = InitFrameNodes("myButton");
605 auto pipline = PipelineContext::GetMainPipelineContext();
606 pipline->SetupRootElement();
607 buttonFrameNode->GetOrCreateFocusHub();
608 auto gestureHub = buttonFrameNode->GetOrCreateGestureEventHub();
609 gestureHub->InitDragDropEvent();
610 /**
611 * @tc.steps: step4. create OnDragStart params
612 */
613 GestureEvent info;
614 info.SetInputEventType(InputEventType::MOUSE_BUTTON);
615 DragDropInfo dragDropInfo;
616 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
617 /**
618 * @tc.steps: step5. call OnDragStart abnormal
619 */
620 event->SetResult(DragRet::DRAG_FAIL);
621 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
622 gestureHub->OnDragStart(info, pipline, buttonFrameNode, dragDropInfo, event);
623 EXPECT_EQ(event->GetResult(), DragRet::DRAG_FAIL);
624 EXPECT_EQ(info.GetInputEventType(), InputEventType::MOUSE_BUTTON);
625 }
626
CreateFrameNodeGroup(int32_t targetId,size_t childCount)627 RefPtr<FrameNode> CreateFrameNodeGroup(int32_t targetId, size_t childCount)
628 {
629 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
630 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, targetId, pagePattern);
631 for (size_t i = 0; i < childCount; ++i) {
632 ++targetId;
633 auto childNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, targetId, nullptr);
634 childNode->MountToParent(pageNode);
635 }
636 return pageNode;
637 }
638
CreateRecognizerGroup(const RefPtr<NG::FrameNode> & parentNode)639 RefPtr<NG::NGGestureRecognizer> CreateRecognizerGroup(const RefPtr<NG::FrameNode>& parentNode)
640 {
641 CHECK_NULL_RETURN(parentNode, nullptr);
642 std::list<RefPtr<NGGestureRecognizer>> recognizers;
643 for (const auto& childNode : parentNode->GetChildren()) {
644 auto childFrameNode = AceType::DynamicCast<FrameNode>(childNode);
645 if (childFrameNode) {
646 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
647 clickRecognizer->AttachFrameNode(childFrameNode);
648 recognizers.emplace_back(clickRecognizer);
649 }
650 }
651 auto recognizerGroup = AceType::MakeRefPtr<NG::ParallelRecognizer>(std::move(recognizers));
652 if (recognizerGroup) {
653 recognizerGroup->AttachFrameNode(parentNode);
654 }
655 return recognizerGroup;
656 }
657
658 /**
659 * @tc.name: AccessibilityRecursionSearchRecognizer
660 * @tc.desc: Test AccessibilityRecursionSearchRecognizer group function
661 * @tc.type: FUNC
662 */
663 HWTEST_F(GestureEventHubTestNg, AccessibilityRecursionSearchRecognizer002, TestSize.Level1)
664 {
665 auto eventHub = AceType::MakeRefPtr<EventHub>();
666 int32_t nodeId = 16;
667 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
668 auto recognizerGroup = CreateRecognizerGroup(parentNode);
669 eventHub->AttachHost(parentNode);
670 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
671 ASSERT_NE(gestureEventHub, nullptr);
672 auto clickRecognizer1 = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, 1);
673 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer1);
674 gestureEventHub->gestureHierarchy_.emplace_back(recognizerGroup);
675 gestureEventHub->IsAccessibilityClickable();
676 EXPECT_EQ(gestureEventHub->gestureHierarchy_.size(), 2);
677 gestureEventHub->gestureHierarchy_.clear();
678 }
679
680 /**
681 * @tc.name: SetMouseDragMonitorState002
682 * @tc.desc: Test SetMouseDragMonitorState function
683 * @tc.type: FUNC
684 */
685 HWTEST_F(GestureEventHubTestNg, SetMouseDragMonitorState002, TestSize.Level1)
686 {
687 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
688 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
689 ASSERT_NE(guestureEventHub, nullptr);
690
691 auto mock = AceType::DynamicCast<MockInteractionInterface>(InteractionInterface::GetInstance());
692 ASSERT_NE(mock, nullptr);
693 EXPECT_CALL(*mock, SetMouseDragMonitorState(testing::_)).Times(1).WillOnce(Return(false));
694 guestureEventHub->SetMouseDragMonitorState(false);
695 EXPECT_CALL(*mock, SetMouseDragMonitorState(testing::_)).WillRepeatedly(Return(true));
696 guestureEventHub->SetMouseDragMonitorState(true);
697 }
698
699 /**
700 * @tc.name: FireCustomerOnDragEnd002
701 * @tc.desc: Test FireCustomerOnDragEnd.
702 * @tc.type: FUNC
703 */
704 HWTEST_F(GestureEventHubTestNg, FireCustomerOnDragEnd002, TestSize.Level1)
705 {
706 /**
707 * @tc.steps: step1. Create gestureEventHub.
708 * @tc.expected: instance is not null.
709 */
710 auto eventHub = AceType::MakeRefPtr<EventHub>();
711 auto gestureEventHub = eventHub->GetOrCreateGestureEventHub();
712 ASSERT_NE(gestureEventHub, nullptr);
713
714 auto context = PipelineContext::GetCurrentContext();
715
716 gestureEventHub->FireCustomerOnDragEnd(context, nullptr);
717 gestureEventHub->FireCustomerOnDragEnd(nullptr, eventHub);
718 context->dragDropManager_ = nullptr;
719 gestureEventHub->FireCustomerOnDragEnd(context, eventHub);
720 }
721
722 /**
723 * @tc.name: OnDragStart005
724 * @tc.desc: Test DragPreviewOption
725 * @tc.type: FUNC
726 */
727 HWTEST_F(GestureEventHubTestNg, OnDragStart005, TestSize.Level1)
728 {
729 auto [webFrameNode, columnNode] = InitFrameNodes(V2::WEB_ETS_TAG);
730 auto pipline = PipelineContext::GetMainPipelineContext();
731 auto overlayManager = pipline->GetOverlayManager();
732 ASSERT_NE(overlayManager, nullptr);
733 pipline->SetupRootElement();
734 webFrameNode->GetOrCreateFocusHub();
735 overlayManager->SetIsMenuShow(true);
736 overlayManager->pixmapColumnNodeWeak_ = AceType::WeakClaim(AceType::RawPtr(columnNode));
737 auto gestureHub = webFrameNode->GetOrCreateGestureEventHub();
738 gestureHub->InitDragDropEvent();
739 overlayManager->MountPixelMapToRootNode(columnNode);
740 overlayManager->isMenuShow_ = true;
741 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
742 ASSERT_NE(pixelMap, nullptr);
743 EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(testing::Return(4.0f));
744 EXPECT_CALL(*pixelMap, GetHeight()).WillRepeatedly(testing::Return(5.0f));
745 gestureHub->SetPixelMap(pixelMap);
746 auto containerId = Container::CurrentId();
747 auto subwindow = AceType::MakeRefPtr<MockSubwindow>();
748 SubwindowManager::GetInstance()->AddSubwindow(containerId, subwindow);
749 SubwindowManager::GetInstance()->SetCurrentSubwindow(subwindow);
750 EXPECT_CALL(*subwindow, ShowPreviewNG(false)).WillRepeatedly(testing::Return(true));
751 EXPECT_CALL(*subwindow, GetOverlayManager()).WillRepeatedly(testing::Return(overlayManager));
752 EXPECT_CALL(*subwindow, GetMenuPreviewCenter(_)).WillRepeatedly(testing::Return(true));
753 MockContainer::SetUp();
754 MockContainer::Current();
755 GestureEvent info;
756 auto dragDropManager = pipline->GetDragDropManager();
757 ASSERT_NE(dragDropManager, nullptr);
758 dragDropManager->SetIsDragWithContextMenu(true);
759 dragDropManager->PushGatherPixelMap(pixelMap);
760 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
761 DragDropInfo dragDropInfo = { customNode };
762 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
763 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
764 event->SetData(unifiedData);
765 EXPECT_CALL(*unifiedData, GetSize()).WillRepeatedly(testing::Return(4));
766 NG::DragPreviewOption option { true, false, true, true };
767 webFrameNode->SetDragPreviewOptions(option);
768 gestureHub->dragEventActuator_->preScaledPixelMap_ = pixelMap;
769 gestureHub->OnDragStart(info, pipline, webFrameNode, dragDropInfo, event);
770 ASSERT_NE(gestureHub->pixelMap_, nullptr);
771 ASSERT_NE(gestureHub->dragEventActuator_, nullptr);
772 EXPECT_NE(gestureHub->GetPreScaledPixelMapIfExist(1.0f, pixelMap), nullptr);
773 SubwindowManager::GetInstance()->subwindowMap_.clear();
774 SubwindowManager::GetInstance()->SetCurrentSubwindow(nullptr);
775 MockContainer::TearDown();
776 }
777
778 /**
779 * @tc.name: DragItemGrayEffectTest001
780 * @tc.desc: Test GetGrayedState And SetGrayedState
781 * @tc.type: FUNC
782 */
783 HWTEST_F(GestureEventHubTestNg, DragItemGrayEffectTest001, TestSize.Level1)
784 {
785 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
786 ASSERT_NE(dragDropManager, nullptr);
787 auto grayedState = dragDropManager->GetGrayedState();
788 EXPECT_EQ(grayedState, false);
789
790 dragDropManager->SetGrayedState(true);
791 grayedState = dragDropManager->GetGrayedState();
792 EXPECT_EQ(grayedState, true);
793
794 dragDropManager->SetGrayedState(false);
795 grayedState = dragDropManager->GetGrayedState();
796 EXPECT_EQ(grayedState, false);
797 }
798
799 /**
800 * @tc.name: DragItemGrayEffectTest002
801 * @tc.desc: Test HandleDragThroughMouse And HandleDragEndAction
802 * @tc.type: FUNC
803 */
804 HWTEST_F(GestureEventHubTestNg, DragItemGrayEffectTest002, TestSize.Level1)
805 {
806 auto pipline = PipelineContext::GetMainPipelineContext();
807 pipline->dragDropManager_->SetGrayedState(false);
808 auto frameNode = FrameNode::CreateFrameNode("test", 100, AceType::MakeRefPtr<Pattern>());
809 frameNode->GetRenderContext()->UpdateOpacity(1.0f);
810 auto grayedOpacity = frameNode->GetRenderContext()->GetOpacityValue();
811 EXPECT_EQ(grayedOpacity, 1.0f);
812
813 NG::DragPreviewOption dragPreviewOptions;
814 dragPreviewOptions.isDefaultDragItemGrayEffectEnabled = true;
815 frameNode->SetDragPreviewOptions(dragPreviewOptions);
816 auto eventHub = AceType::MakeRefPtr<EventHub>();
817 auto gestureEventHub = eventHub->GetOrCreateGestureEventHub();
818 ASSERT_NE(gestureEventHub, nullptr);
819 gestureEventHub->HandleDragThroughMouse(frameNode);
820 grayedOpacity = frameNode->GetPreGrayedOpacity();
821 EXPECT_EQ(grayedOpacity, 1.0f);
822 auto renderOpacity = frameNode->GetRenderContext()->GetOpacityValue();
823 EXPECT_EQ(renderOpacity, 0.4f);
824
825 gestureEventHub->HandleDragEndAction(gestureEventHub->dragframeNodeInfo_);
826 auto opacity = frameNode->GetRenderContext()->GetOpacityValue();
827 EXPECT_EQ(opacity, 1.0f);
828 }
829
830 /**
831 * @tc.name: DragItemGrayEffectTest003
832 * @tc.desc: Test HandleDragThroughTouch And HandleDragEndAction
833 * @tc.type: FUNC
834 */
835 HWTEST_F(GestureEventHubTestNg, DragItemGrayEffectTest003, TestSize.Level1)
836 {
837 auto frameNode = FrameNode::CreateFrameNode("test", 100, AceType::MakeRefPtr<Pattern>());
838 frameNode->GetRenderContext()->UpdateOpacity(1.0f);
839 auto grayedOpacity = frameNode->GetRenderContext()->GetOpacityValue();
840 EXPECT_EQ(grayedOpacity, 1.0f);
841
842 NG::DragPreviewOption dragPreviewOptions;
843 dragPreviewOptions.isDefaultDragItemGrayEffectEnabled = true;
844 frameNode->SetDragPreviewOptions(dragPreviewOptions);
845 auto eventHub = AceType::MakeRefPtr<EventHub>();
846 auto gestureEventHub = eventHub->GetOrCreateGestureEventHub();
847 ASSERT_NE(gestureEventHub, nullptr);
848 gestureEventHub->HandleDragThroughTouch(frameNode);
849 grayedOpacity = frameNode->GetPreGrayedOpacity();
850 EXPECT_EQ(grayedOpacity, 1.0f);
851 auto renderOpacity = frameNode->GetRenderContext()->GetOpacityValue();
852 EXPECT_EQ(renderOpacity, 0.4f);
853
854 gestureEventHub->HandleDragEndAction(gestureEventHub->dragframeNodeInfo_);
855 auto opacity = frameNode->GetRenderContext()->GetOpacityValue();
856 EXPECT_EQ(opacity, 1.0f);
857 }
858
859 /**
860 * @tc.name: SetMouseDragGatherPixelMaps002
861 * @tc.desc: Test SetMouseDragGatherPixelMaps
862 * @tc.type: FUNC
863 */
864 HWTEST_F(GestureEventHubTestNg, SetMouseDragGatherPixelMaps002, TestSize.Level1)
865 {
866 auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
867 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
868 ASSERT_NE(guestureEventHub, nullptr);
869 auto eventHub = guestureEventHub->eventHub_.Upgrade();
870
871 auto pipeline = PipelineContext::GetCurrentContext();
872 CHECK_NULL_VOID(pipeline);
873 auto dragDropManager = pipeline->GetDragDropManager();
874 CHECK_NULL_VOID(dragDropManager);
875 dragDropManager->ClearGatherPixelMap();
876 auto mainPipeline = PipelineContext::GetMainPipelineContext();
877
878 mainPipeline->overlayManager_ = nullptr;
879 guestureEventHub->SetNotMouseDragGatherPixelMaps();
880 pipeline->dragDropManager_ = nullptr;
881 guestureEventHub->SetNotMouseDragGatherPixelMaps();
882 pipeline = nullptr;
883 guestureEventHub->SetNotMouseDragGatherPixelMaps();
884 }
885
886 /**
887 * @tc.name: GestureEventHubTest034
888 * @tc.desc: Test ProcessTouchTestHierarchy
889 * @tc.type: FUNC
890 */
891 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest034, TestSize.Level1)
892 {
893 auto eventHub = AceType::MakeRefPtr<EventHub>();
894 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
895 eventHub->AttachHost(frameNode);
896 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
897 TouchRestrict touchRestrict;
898 std::list<RefPtr<NGGestureRecognizer>> innerTargets;
899 TouchTestResult finalResult;
900 ResponseLinkResult responseLinkResult;
901 std::vector<RefPtr<NGGestureRecognizer>> vc;
902 vc.push_back(AceType::MakeRefPtr<ClickRecognizer>());
903 auto exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(vc);
904 std::vector<RefPtr<NGGestureRecognizer>> parallelVc;
905 parallelVc.push_back(AceType::MakeRefPtr<ClickRecognizer>());
906 auto parallelRecognizer = AceType::MakeRefPtr<ParallelRecognizer>(parallelVc);
907 gestureEventHub->externalExclusiveRecognizer_.push_back(exclusiveRecognizer);
908 gestureEventHub->externalParallelRecognizer_.push_back(parallelRecognizer);
909 gestureEventHub->ProcessTouchTestHierarchy(
910 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, nullptr, responseLinkResult);
911 EXPECT_TRUE(finalResult.empty());
912 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Low
913 innerTargets.emplace_back(clickRecognizer);
914 gestureEventHub->gestureHierarchy_.emplace_back(nullptr);
915 auto clickRecognizer2 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1);
916 clickRecognizer2->SetPriorityMask(GestureMask::IgnoreInternal); // current will assigned to this
917 auto clickRecognizer3 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::High
918 clickRecognizer3->SetPriority(GesturePriority::High);
919 auto clickRecognizer4 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Parallel
920 clickRecognizer4->SetPriority(GesturePriority::Parallel);
921 auto clickRecognizer5 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Parallel
922 clickRecognizer5->SetPriority(GesturePriority::Parallel);
923 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
924 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer4);
925 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer2);
926 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer3);
927 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer5);
928 clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1);
929 innerTargets.emplace_back(clickRecognizer);
930 std::list<RefPtr<NGGestureRecognizer>> innerTargets3;
931 innerTargets3.emplace_back(clickRecognizer);
932 int32_t nodeId = 16;
933 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
934 auto recognizerGroup = CreateRecognizerGroup(parentNode);
935 eventHub->AttachHost(parentNode);
936 gestureEventHub->gestureHierarchy_.emplace_back(recognizerGroup);
937 gestureEventHub->ProcessTouchTestHierarchy(
938 COORDINATE_OFFSET, touchRestrict, innerTargets3, finalResult, TOUCH_ID, nullptr, responseLinkResult);
939 }
940 } // namespace OHOS::Ace::NG
941