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