• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 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/drag_event_test_ng.h"
17 #include "test/mock/base/mock_task_executor.h"
18 #include "test/unittest/core/pattern/scrollable/mock_scrollable.h"
19 #include "core/components_ng/manager/drag_drop/drag_drop_func_wrapper.h"
20 
21 using namespace testing;
22 using namespace testing::ext;
23 
24 namespace OHOS::Ace::NG {
25 /**
26  * @tc.name: DragEventActuatorMountGatherNodeTest031
27  * @tc.desc: Test UpdatePreviewAttr function.
28  * @tc.type: FUNC
29  */
30 HWTEST_F(DragEventTestNg, DragEventActuatorMountGatherNodeTest031, TestSize.Level1)
31 {
32     auto eventHub = AceType::MakeRefPtr<EventHub>();
33     ASSERT_NE(eventHub, nullptr);
34     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>(), false);
35     ASSERT_NE(frameNode, nullptr);
36     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
37     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
38     ASSERT_NE(gestureEventHub, nullptr);
39     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
40         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
41     ASSERT_NE(dragEventActuator, nullptr);
42     auto imageNode = FrameNode::GetOrCreateFrameNode(V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anondcb5a0f70102() 43         []() { return AceType::MakeRefPtr<ImagePattern>(); });
44     ASSERT_NE(imageNode, nullptr);
45     Dimension dimen(2.0);
46     BlurBackGroundInfo bgBackEffect = { { dimen, 1.0f, 1.0f, Color::TRANSPARENT, AdaptiveColor::DEFAULT,
47         { { 2.0f, 2.0f } } } };
48     Shadow shadow;
49     shadow.SetIsFilled(false);
50     shadow.SetOffset(Offset(5, 5));
51     shadow.SetBlurRadius(10.0);
52     shadow.SetColor(Color::FromARGB(255, 255, 0, 0));
53     BorderRadiusProperty borderRadius;
54     borderRadius.SetRadius(Dimension(0.1));
55     OptionsAfterApplied optionTmp = { 0, shadow, "test", true, borderRadius, { bgBackEffect } };
56     NG::DragPreviewOption previewOptions;
57     previewOptions.options = optionTmp;
58     frameNode->SetDragPreviewOptions(previewOptions);
59     dragEventActuator->UpdatePreviewAttr(frameNode, imageNode);
60     EXPECT_EQ(shadow.GetBlurRadius(), 10.0);
61 }
62 /**
63  * @tc.name: DragEventActuatorUpdatePreviewAttrTest032
64  * @tc.desc: Test PrepareRadiusParametersForDragData function.
65  * @tc.type: FUNC
66  */
67 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest032, TestSize.Level1)
68 {
69     auto eventHub = AceType::MakeRefPtr<EventHub>();
70     ASSERT_NE(eventHub, nullptr);
71     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>(), false);
72     ASSERT_NE(frameNode, nullptr);
73     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
74     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
75     ASSERT_NE(gestureEventHub, nullptr);
76     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
77         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
78     ASSERT_NE(dragEventActuator, nullptr);
79     Dimension dimen(2.0);
80     BlurBackGroundInfo bgBackEffect = { { dimen, 1.0f, 1.0f, Color::TRANSPARENT, AdaptiveColor::DEFAULT,
81         { { 2.0f, 2.0f } } } };
82     Shadow shadow;
83     shadow.SetIsFilled(false);
84     shadow.SetOffset(Offset(5, 5));
85     shadow.SetBlurRadius(10.0);
86     shadow.SetColor(Color::FromARGB(255, 255, 0, 0));
87     BorderRadiusProperty borderRadius;
88     borderRadius.radiusBottomRight = dimen;
89     OptionsAfterApplied optionTmp = { 0, shadow, "test", true, borderRadius, { bgBackEffect } };
90     NG::DragPreviewOption previewOptions;
91     previewOptions.options = optionTmp;
92     frameNode->SetDragPreviewOptions(previewOptions);
93     std::unique_ptr<JsonValue> arkExtraInfoJson = std::make_unique<JsonValue>();
94     dragEventActuator->PrepareRadiusParametersForDragData(frameNode, arkExtraInfoJson);
95     BorderRadiusProperty borderRadiusTwo;
96     borderRadiusTwo.radiusBottomLeft = dimen;
97     optionTmp = { 0, shadow, "test", true, borderRadiusTwo, { bgBackEffect } };
98     previewOptions.options = optionTmp;
99     frameNode->SetDragPreviewOptions(previewOptions);
100     dragEventActuator->PrepareRadiusParametersForDragData(frameNode, arkExtraInfoJson);
101     EXPECT_EQ(shadow.GetBlurRadius(), 10.0);
102 }
103 
104 /**
105  * @tc.name: DragEventActuatorUpdatePreviewAttrTest034
106  * @tc.desc: Create DragEventActuator and invoke longPressUpdate callback.
107  * @tc.type: FUNC
108  */
109 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest034, TestSize.Level1)
110 {
111     auto eventHub = AceType::MakeRefPtr<EventHub>();
112     ASSERT_NE(eventHub, nullptr);
113     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
114     ASSERT_NE(frameNode, nullptr);
115     DragDropInfo dragDropInfo;
116     frameNode->SetDragPreview(dragDropInfo);
117     frameNode->SetDraggable(true);
118     auto focusHub = frameNode->GetOrCreateFocusHub();
119     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
120     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
121     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
122         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
123     ASSERT_NE(dragEventActuator, nullptr);
__anondcb5a0f70202(GestureEvent& info) 124     GestureEventFunc actionStart = [](GestureEvent& info) {};
__anondcb5a0f70302() 125     GestureEventNoParameter actionCancel = []() {};
126     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
127         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
128     dragEventActuator->ReplaceDragEvent(dragEvent);
129     dragEventActuator->SetCustomDragEvent(dragEvent);
130     auto getEventTargetImpl = eventHub->CreateGetEventTargetImpl();
131     TouchTestResult finalResult;
132     ResponseLinkResult responseLinkResult;
133     dragEventActuator->OnCollectTouchTarget(
134         COORDINATE_OFFSET, DRAG_TOUCH_RESTRICT, getEventTargetImpl, finalResult, responseLinkResult);
135     SystemProperties::debugEnabled_ = true;
136     GestureEvent info = GestureEvent();
137     NG::DragPreviewOption previewOptions;
138     previewOptions.isNumber = true;
139     previewOptions.badgeNumber = 2;
140     frameNode->SetDragPreviewOptions(previewOptions);
141     gestureEventHub->previewMode_ = MenuPreviewMode::IMAGE;
142     (*(dragEventActuator->previewLongPressRecognizer_->onAction_))(info);
__anondcb5a0f70402(const KeyEvent& event) 143     auto onKeyEvent = [](const KeyEvent& event) -> bool { return true; };
144     focusHub->SetOnKeyEventInternal(onKeyEvent, OnKeyEventType::CONTEXT_MENU);
145     dragEventActuator->OnCollectTouchTarget(
146         COORDINATE_OFFSET, DRAG_TOUCH_RESTRICT, getEventTargetImpl, finalResult, responseLinkResult);
147     (*(dragEventActuator->previewLongPressRecognizer_->onAction_))(info);
148     EXPECT_EQ(previewOptions.isNumber, true);
149 }
150 
151 /**
152  * @tc.name: DragEventActuatorUpdatePreviewAttrTest036
153  * @tc.desc: Create DragEventActuator and invoke thumbnail callback.
154  * @tc.type: FUNC
155  */
156 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest036, TestSize.Level1)
157 {
158     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
159     ASSERT_NE(frameNode, nullptr);
160     frameNode->SetDraggable(true);
161     NG::DragDropInfo dragPreviewInfo;
162     dragPreviewInfo.inspectorId = "123";
163     RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(static_cast<void*>(new char[0]));
164     dragPreviewInfo.pixelMap = pixelMap;
165     frameNode->SetDragPreview(dragPreviewInfo);
166 
167     auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
168     EXPECT_NE(eventHub, nullptr);
169     eventHub->AttachHost(frameNode);
__anondcb5a0f70502(const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams) 170     auto onDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams) -> DragDropInfo {
171         DragDropInfo info;
172         info.inspectorId = "123";
173         void* voidPtr = static_cast<void*>(new char[0]);
174         info.pixelMap = PixelMap::CreatePixelMap(voidPtr);
175         return info;
176     };
177     eventHub->SetOnDragStart(std::move(onDragStart));
178 
179     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
180     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
181         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
182 
183     TouchTestResult finalResult;
184     ResponseLinkResult responseLinkResult;
185     double unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
__anondcb5a0f70602(GestureEvent& info) 186     GestureEventFunc actionStart = [&unknownPropertyValue](GestureEvent& info) {};
__anondcb5a0f70702() 187     GestureEventNoParameter actionCancel = [&unknownPropertyValue]() {};
188     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
189         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
190     dragEventActuator->ReplaceDragEvent(dragEvent);
191     dragEventActuator->SetCustomDragEvent(dragEvent);
192 
193     auto getEventTargetImpl = eventHub->CreateGetEventTargetImpl();
194     frameNode->GetOrCreateFocusHub();
195     dragEventActuator->OnCollectTouchTarget(
196         COORDINATE_OFFSET, DRAG_TOUCH_RESTRICT, getEventTargetImpl, finalResult, responseLinkResult);
197 
198     dragEventActuator->longPressRecognizer_->callback_(Offset(WIDTH, HEIGHT));
199     EXPECT_EQ(gestureEventHub->pixelMap_, nullptr);
200 }
201 
202 /**
203  * @tc.name: DragEventActuatorUpdatePreviewAttrTest037
204  * @tc.desc: Create DragEventActuator and invoke longPressUpdate callback.
205  * @tc.type: FUNC
206  */
207 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest037, TestSize.Level1)
208 {
209     auto eventHub = AceType::MakeRefPtr<EventHub>();
210     ASSERT_NE(eventHub, nullptr);
211     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
212     ASSERT_NE(frameNode, nullptr);
213     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
214     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
215     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
216         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
217     ASSERT_NE(dragEventActuator, nullptr);
__anondcb5a0f70802(GestureEvent& info) 218     GestureEventFunc actionStart = [](GestureEvent& info) {};
__anondcb5a0f70902() 219     GestureEventNoParameter actionCancel = []() {};
220     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
221         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
222     dragEventActuator->ReplaceDragEvent(dragEvent);
223     dragEventActuator->SetCustomDragEvent(dragEvent);
224     auto getEventTargetImpl = eventHub->CreateGetEventTargetImpl();
225     TouchTestResult finalResult;
226     ResponseLinkResult responseLinkResult;
227     dragEventActuator->OnCollectTouchTarget(
228         COORDINATE_OFFSET, DRAG_TOUCH_RESTRICT, getEventTargetImpl, finalResult, responseLinkResult);
229     GestureEvent info = GestureEvent();
230     auto pipeline = PipelineContext::GetCurrentContext();
231     auto manager = pipeline->GetOverlayManager();
232     ASSERT_NE(manager, nullptr);
233     auto childNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
234     ASSERT_NE(childNode, nullptr);
235     auto parentNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
236     ASSERT_NE(parentNode, nullptr);
237     frameNode->SetParent(parentNode);
238     dragEventActuator->itemParentNode_ = parentNode;
239     manager->pixmapColumnNodeWeak_ = WeakPtr<FrameNode>(AceType::DynamicCast<FrameNode>(frameNode));
240     dragEventActuator->isSelectedItemNode_ = true;
241     auto pattern = AceType::MakeRefPtr<GridPattern>();
242     auto itemPattern = AceType::MakeRefPtr<GridItemPattern>(nullptr, GridItemStyle::NONE);
243     itemPattern->isSelected_ = true;
244     auto tempChildNode = FrameNode::CreateFrameNode("BackButton", 2, AceType::MakeRefPtr<Pattern>());
245     ASSERT_NE(tempChildNode, nullptr);
246     childNode->pattern_ = itemPattern;
247     tempChildNode->pattern_ = itemPattern;
248     frameNode->AddChild(childNode);
249     frameNode->AddChild(tempChildNode);
250     pattern->frameNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
251     pattern->info_.startIndex_ = 0;
252     pattern->info_.endIndex_ = 3;
253     parentNode->pattern_ = pattern;
254     (*(dragEventActuator->previewLongPressRecognizer_->onAction_))(info);
255     EXPECT_EQ(itemPattern->isSelected_, true);
256 }
257 
258 /**
259  * @tc.name: DragEventActuatorUpdatePreviewAttrTest038
260  * @tc.desc: SetGatherNodeAboveFilter
261  * @tc.type: FUNC
262  */
263 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest038, TestSize.Level1)
264 {
265     auto eventHub = AceType::MakeRefPtr<EventHub>();
266     ASSERT_NE(eventHub, nullptr);
267     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
268     ASSERT_NE(frameNode, nullptr);
269     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
270     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
271     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
272         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
273     ASSERT_NE(dragEventActuator, nullptr);
274     auto childNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
275     ASSERT_NE(childNode, nullptr);
276     auto parentNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
277     ASSERT_NE(parentNode, nullptr);
278     frameNode->SetParent(parentNode);
279     dragEventActuator->itemParentNode_ = parentNode;
280     dragEventActuator->isSelectedItemNode_ = true;
281     auto pattern = AceType::MakeRefPtr<GridPattern>();
282     auto itemPattern = AceType::MakeRefPtr<GridItemPattern>(nullptr, GridItemStyle::NONE);
283     itemPattern->isSelected_ = true;
284     auto tempChildNode = FrameNode::CreateFrameNode("BackButton", 2, AceType::MakeRefPtr<Pattern>());
285     ASSERT_NE(tempChildNode, nullptr);
286     childNode->pattern_ = itemPattern;
287     tempChildNode->pattern_ = itemPattern;
288     frameNode->AddChild(childNode);
289     frameNode->AddChild(tempChildNode);
290     pattern->frameNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
291     pattern->info_.startIndex_ = 0;
292     pattern->info_.endIndex_ = 3;
293     parentNode->pattern_ = pattern;
294     dragEventActuator->SetGatherNodeAboveFilter(dragEventActuator);
295     EXPECT_EQ(itemPattern->isSelected_, true);
296 }
297 
298 /**
299  * @tc.name: DragEventActuatorUpdatePreviewAttrTest039
300  * @tc.desc: Test GetOrCreateGatherNode function.
301  * @tc.type: FUNC
302  */
303 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest039, TestSize.Level1)
304 {
305     auto eventHub = AceType::MakeRefPtr<EventHub>();
306     ASSERT_NE(eventHub, nullptr);
307     auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
308     ASSERT_NE(frameNode, nullptr);
309     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
310     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
311     ASSERT_NE(gestureEventHub, nullptr);
312     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
313         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
314     ASSERT_NE(dragEventActuator, nullptr);
315     std::vector<GatherNodeChildInfo> gatherNodeChildInfo(2);
316     auto pipeline = PipelineContext::GetCurrentContext();
317     auto overlayManager = pipeline->GetOverlayManager();
318     ASSERT_NE(overlayManager, nullptr);
319     auto childNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
320     ASSERT_NE(childNode, nullptr);
321     auto parentNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
322     ASSERT_NE(parentNode, nullptr);
323     dragEventActuator->itemParentNode_ = parentNode;
324     dragEventActuator->isSelectedItemNode_ = true;
325     auto pattern = AceType::MakeRefPtr<GridPattern>();
326     auto itemPattern = AceType::MakeRefPtr<GridItemPattern>(nullptr, GridItemStyle::NONE);
327     itemPattern->isSelected_ = true;
328     auto tempChildNode = FrameNode::CreateFrameNode("BackButton", 2, AceType::MakeRefPtr<Pattern>());
329     ASSERT_NE(tempChildNode, nullptr);
330     childNode->pattern_ = itemPattern;
331     tempChildNode->pattern_ = itemPattern;
332     frameNode->AddChild(childNode);
333     frameNode->AddChild(tempChildNode);
334     pattern->frameNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
335     pattern->info_.startIndex_ = 0;
336     pattern->info_.endIndex_ = 3;
337     parentNode->pattern_ = pattern;
338     auto gatherNode = dragEventActuator->GetOrCreateGatherNode(overlayManager, dragEventActuator, gatherNodeChildInfo);
339     NG::DragPreviewOption previewOptions;
340     previewOptions.isMultiSelectionEnabled = true;
341     frameNode->SetDragPreviewOptions(previewOptions);
342     dragEventActuator->GetOrCreateGatherNode(overlayManager, dragEventActuator, gatherNodeChildInfo);
343     overlayManager->gatherNodeWeak_ = dragEventActuator->CreateGatherNode(dragEventActuator);
344     dragEventActuator->GetOrCreateGatherNode(overlayManager, dragEventActuator, gatherNodeChildInfo);
345     EXPECT_EQ(gatherNode, nullptr);
346 }
347 
348 /**
349  * @tc.name: DragEventActuatorUpdatePreviewAttrTest040
350  * @tc.desc: HandleTouchUpEvent
351  * @tc.type: FUNC
352  */
353 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest040, TestSize.Level1)
354 {
355     auto eventHub = AceType::MakeRefPtr<EventHub>();
356     ASSERT_NE(eventHub, nullptr);
357     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
358     ASSERT_NE(frameNode, nullptr);
359     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
360     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
361     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
362         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
363     ASSERT_NE(dragEventActuator, nullptr);
364     auto childNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
365     ASSERT_NE(childNode, nullptr);
366     auto parentNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
367     ASSERT_NE(parentNode, nullptr);
368     frameNode->SetParent(parentNode);
369     dragEventActuator->itemParentNode_ = parentNode;
370     dragEventActuator->isSelectedItemNode_ = true;
371     auto pattern = AceType::MakeRefPtr<GridPattern>();
372     auto itemPattern = AceType::MakeRefPtr<GridItemPattern>(nullptr, GridItemStyle::NONE);
373     itemPattern->isSelected_ = true;
374     auto tempChildNode = FrameNode::CreateFrameNode("BackButton", 2, AceType::MakeRefPtr<Pattern>());
375     ASSERT_NE(tempChildNode, nullptr);
376     childNode->pattern_ = itemPattern;
377     tempChildNode->pattern_ = itemPattern;
378     frameNode->AddChild(childNode);
379     frameNode->AddChild(tempChildNode);
380     pattern->frameNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
381     pattern->info_.startIndex_ = 0;
382     pattern->info_.endIndex_ = 3;
383     parentNode->pattern_ = pattern;
384     dragEventActuator->HandleTouchUpEvent();
385     auto pipelineContext = PipelineContext::GetCurrentContext();
386     ASSERT_NE(pipelineContext, nullptr);
387     auto dragDropManager = pipelineContext->GetDragDropManager();
388     ASSERT_NE(dragDropManager, nullptr);
389     DragDropGlobalController::GetInstance().SetPreDragStatus(PreDragStatus::PREVIEW_LANDING_STARTED);
390     dragEventActuator->HandleTouchUpEvent();
391     dragEventActuator->SetResponseRegionFull();
392     dragEventActuator->ResetResponseRegion();
393     dragEventActuator->isResponseRegionFull_ = false;
394     dragEventActuator->ResetResponseRegion();
395     EXPECT_EQ(dragEventActuator->isResponseRegionFull_, false);
396 }
397 
398 /**
399  * @tc.name: DragEventActuatorUpdatePreviewAttrTest041
400  * @tc.desc: AddTouchListener
401  * @tc.type: FUNC
402  */
403 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest041, TestSize.Level1)
404 {
405     auto eventHub = AceType::MakeRefPtr<EventHub>();
406     ASSERT_NE(eventHub, nullptr);
407     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
408     ASSERT_NE(frameNode, nullptr);
409     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
410     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
411     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
412         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
413     ASSERT_NE(dragEventActuator, nullptr);
__anondcb5a0f70a02(GestureEvent& info) 414     GestureEventFunc actionStart = [](GestureEvent& info) {};
__anondcb5a0f70b02() 415     GestureEventNoParameter actionCancel = []() {};
416     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
417         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
418     dragEventActuator->ReplaceDragEvent(dragEvent);
419     TouchRestrict touchRestrict;
420     dragEventActuator->AddTouchListener(touchRestrict);
421     auto touchEventActuator = gestureEventHub->touchEventActuator_;
422     ASSERT_NE(touchEventActuator, nullptr);
423     auto events = touchEventActuator->touchEvents_;
424     TouchEventInfo info("onTouch");
425     TouchLocationInfo touchInfo1(1);
426     touchInfo1.SetTouchType(TouchType::CANCEL);
427     info.AddTouchLocationInfo(std::move(touchInfo1));
428     ASSERT_NE(events.size(), 0);
429     for (auto event : events) {
430         event->callback_(info);
431     }
432     info.touches_.clear();
433     touchInfo1.SetTouchType(TouchType::UP);
434     info.AddTouchLocationInfo(std::move(touchInfo1));
435     for (auto event : events) {
436         event->callback_(info);
437     }
438     info.touches_.clear();
439     touchInfo1.SetTouchType(TouchType::MOVE);
440     info.AddTouchLocationInfo(std::move(touchInfo1));
441     for (auto event : events) {
442         event->callback_(info);
443     }
444     info.touches_.clear();
445     for (auto event : events) {
446         event->callback_(info);
447     }
448     EXPECT_EQ(gestureEventHub->GetTextDraggable(), false);
449 }
450 
451 /**
452  * @tc.name: DragEventActuatorUpdatePreviewAttrTest042
453  * @tc.desc: AddTouchListener
454  * @tc.type: FUNC
455  */
456 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest042, TestSize.Level1)
457 {
458     auto eventHub = AceType::MakeRefPtr<EventHub>();
459     ASSERT_NE(eventHub, nullptr);
460     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
461     ASSERT_NE(frameNode, nullptr);
462     auto focusHub = frameNode->GetOrCreateFocusHub();
463     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
464     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
465     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
466         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
467     ASSERT_NE(dragEventActuator, nullptr);
__anondcb5a0f70c02(GestureEvent& info) 468     GestureEventFunc actionStart = [](GestureEvent& info) {};
__anondcb5a0f70d02() 469     GestureEventNoParameter actionCancel = []() {};
470     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
471         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
472     dragEventActuator->ReplaceDragEvent(dragEvent);
473     TouchRestrict touchRestrict;
__anondcb5a0f70e02(const KeyEvent& event) 474     auto onKeyEvent = [](const KeyEvent& event) -> bool { return true; };
475     focusHub->SetOnKeyEventInternal(onKeyEvent, OnKeyEventType::CONTEXT_MENU);
476     dragEventActuator->AddTouchListener(touchRestrict);
477     auto touchEventActuator = gestureEventHub->touchEventActuator_;
478     ASSERT_NE(touchEventActuator, nullptr);
479     auto events = touchEventActuator->touchEvents_;
480     TouchEventInfo info("onTouch");
481     TouchLocationInfo touchInfo1(1);
482     touchInfo1.SetTouchType(TouchType::MOVE);
483     info.AddTouchLocationInfo(std::move(touchInfo1));
484     for (auto event : events) {
485         event->callback_(info);
486     }
487     EXPECT_EQ(gestureEventHub->GetTextDraggable(), false);
488 }
489 
490 /**
491  * @tc.name: DragEventActuatorUpdatePreviewAttrTest043
492  * @tc.desc: Create DragEventActuator and invoke HideTextAnimation function.
493  * @tc.type: FUNC
494  */
495 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest043, TestSize.Level1)
496 {
497     auto eventHub = AceType::MakeRefPtr<EventHub>();
498     ASSERT_NE(eventHub, nullptr);
499     auto frameNode = FrameNode::CreateFrameNode(
500         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
501     ASSERT_NE(frameNode, nullptr);
502     NG::DragDropInfo dragPreviewInfo;
503     void* voidPtr = static_cast<void*>(new char[0]);
504     RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
505     dragPreviewInfo.pixelMap = pixelMap;
506     frameNode->SetDragPreview(dragPreviewInfo);
507     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
508     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
509     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
510         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
511     ASSERT_NE(dragEventActuator, nullptr);
512     frameNode->SetDraggable(true);
513     gestureEventHub->SetTextDraggable(true);
514     auto pattern = AceType::MakeRefPtr<TextPattern>();
515     ASSERT_NE(pattern, nullptr);
516     auto childNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
517     ASSERT_NE(childNode, nullptr);
518     auto patterns = AceType::MakeRefPtr<TextDragPattern>();
519     patterns->CreateNodePaintMethod();
520     childNode->pattern_ = patterns;
521     pattern->dragNode_ = childNode;
522     frameNode->pattern_ = pattern;
523 
524     auto pipeline = PipelineContext::GetCurrentContext();
525     auto manager = pipeline->GetOverlayManager();
526     manager->pixmapColumnNodeWeak_ = childNode;
527     dragEventActuator->HideTextAnimation();
528     auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
529     EXPECT_CALL(*pixmap, GetWidth()).WillRepeatedly(Return(200));
530     gestureEventHub->pixelMap_ = pixmap;
531     dragEventActuator->HideTextAnimation(true);
532     EXPECT_EQ(gestureEventHub->GetTextDraggable(), true);
533 }
534 
535 /**
536  * @tc.name: DragEventActuatorUpdatePreviewAttrTest044
537  * @tc.desc: Create GetPreviewPixelMap and invoke HideTextAnimation function.
538  * @tc.type: FUNC
539  */
540 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest044, TestSize.Level1)
541 {
542     auto eventHub = AceType::MakeRefPtr<EventHub>();
543     ASSERT_NE(eventHub, nullptr);
544     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 1, AceType::MakeRefPtr<TextPattern>());
545     ASSERT_NE(frameNode, nullptr);
546     void* voidPtr = static_cast<void*>(new char[0]);
547     RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
548     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
549     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
550     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
551         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
552     ASSERT_NE(dragEventActuator, nullptr);
553     gestureEventHub->SetTextDraggable(true);
554 
555     gestureEventHub->pixelMap_ = pixelMap;
556     frameNode->UpdateInspectorId("testid");
557     auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>();
558     ASSERT_NE(layoutProperty, nullptr);
559     frameNode->layoutProperty_ = layoutProperty;
560     Inspector::offscreenNodes.clear();
561     Inspector::AddOffscreenNode(frameNode);
562     DragDropFuncWrapper::GetPreviewPixelMap("testid", frameNode);
563     layoutProperty->propVisibility_ = VisibleType::GONE;
564     DragDropFuncWrapper::GetPreviewPixelMap("testid", frameNode);
565     layoutProperty->propVisibility_ = VisibleType::INVISIBLE;
566     DragDropFuncWrapper::GetPreviewPixelMap("testid", frameNode);
567     EXPECT_EQ(gestureEventHub->GetTextDraggable(), true);
568 }
569 
570 /**
571  * @tc.name: DragEventActuatorUpdatePreviewAttrTest045
572  * @tc.desc: Create DragEventActuator and invoke CreateTiledPixelMap function.
573  * @tc.type: FUNC
574  */
575 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest045, TestSize.Level1)
576 {
577     auto eventHub = AceType::MakeRefPtr<EventHub>();
578     ASSERT_NE(eventHub, nullptr);
579     auto framenode = FrameNode::CreateFrameNode(
580         "test", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), false);
581     ASSERT_NE(framenode, nullptr);
582     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
583     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
584     gestureEventHub->contextMenuShowStatus_ = true;
585     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
586         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
587     ASSERT_NE(dragEventActuator, nullptr);
588     ResponseLinkResult responseLinkResult;
589     double unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
__anondcb5a0f70f02(GestureEvent& info) 590     GestureEventFunc actionStart = [&unknownPropertyValue](GestureEvent& info) {};
__anondcb5a0f71002() 591     GestureEventNoParameter actionCancel = [&unknownPropertyValue]() {};
592     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
593         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
594     dragEventActuator->ReplaceDragEvent(dragEvent);
595     dragEventActuator->SetCustomDragEvent(dragEvent);
596     dragEventActuator->SequencedRecognizer_ = nullptr;
597     auto parentNode = FrameNode::CreateFrameNode(
598         "test", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), false);
599     ASSERT_NE(parentNode, nullptr);
600     dragEventActuator->itemParentNode_ = parentNode;
601     auto scrollablePatternDummy =
602         FrameNode::GetOrCreateFrameNode(V2::SCROLL_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anondcb5a0f71102() 603             []() { return AceType::MakeRefPtr<PartiallyMockedScrollable>(); });
604     ASSERT_NE(scrollablePatternDummy, nullptr);
605     auto scrollablePatternDummyPattern = scrollablePatternDummy->GetPattern<PartiallyMockedScrollable>();
606     ASSERT_NE(scrollablePatternDummyPattern, nullptr);
607     std::vector<RefPtr<FrameNode>> childrenNull;
608     std::vector<RefPtr<FrameNode>> children;
609     children.emplace_back(framenode);
610     children.emplace_back(framenode);
611     parentNode->pattern_ = scrollablePatternDummy->GetPattern();
612     NG::DragPreviewOption previewOptions;
613     previewOptions.isMultiTiled = true;
614     framenode->SetDragPreviewOptions(previewOptions);
615     DragDropFuncWrapper::CreateTiledPixelMap(framenode);
616     auto gestureHub = dragEventActuator->gestureEventHub_.Upgrade();
617     ASSERT_NE(gestureHub, nullptr);
618     previewOptions.isMultiTiled = false;
619     framenode->SetDragPreviewOptions(previewOptions);
620     dragEventActuator->isSelectedItemNode_ = true;
621     DragDropFuncWrapper::CreateTiledPixelMap(framenode);
622     EXPECT_EQ(gestureHub->pixelMap_, nullptr);
623 }
624 
625 /**
626  * @tc.name: DragEventActuatorUpdatePreviewAttrTest046
627  * @tc.desc: Create DragEventActuator and invoke CreateTiledPixelMap function.
628  * @tc.type: FUNC
629  */
630 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest046, TestSize.Level1)
631 {
632     auto eventHub = AceType::MakeRefPtr<EventHub>();
633     ASSERT_NE(eventHub, nullptr);
634     auto framenode = FrameNode::CreateFrameNode(
635         "test", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), false);
636     ASSERT_NE(framenode, nullptr);
637     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
638     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
639     gestureEventHub->contextMenuShowStatus_ = true;
640     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
641         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
642     ASSERT_NE(dragEventActuator, nullptr);
643     auto getEventTargetImpl = eventHub->CreateGetEventTargetImpl();
644     ASSERT_NE(getEventTargetImpl, nullptr);
645     TouchTestResult finalResult;
646     ResponseLinkResult responseLinkResult;
647     auto focusHub = framenode->GetOrCreateFocusHub();
648     double unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
__anondcb5a0f71202(GestureEvent& info) 649     GestureEventFunc actionStart = [&unknownPropertyValue](GestureEvent& info) {};
__anondcb5a0f71302() 650     GestureEventNoParameter actionCancel = [&unknownPropertyValue]() {};
651     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
652         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
653     dragEventActuator->ReplaceDragEvent(dragEvent);
654     dragEventActuator->SetCustomDragEvent(dragEvent);
655     dragEventActuator->SequencedRecognizer_ = nullptr;
656     auto parentNode = FrameNode::CreateFrameNode(
657         "test", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), false);
658     ASSERT_NE(parentNode, nullptr);
659     dragEventActuator->itemParentNode_ = parentNode;
660     void* voidPtr = static_cast<void*>(new char[0]);
661     RefPtr<PixelMap> tiledPixelMap = PixelMap::CreatePixelMap(voidPtr);
662     ASSERT_NE(tiledPixelMap, nullptr);
663     std::vector<RefPtr<FrameNode>> children;
664     Rect pixelMapRect;
665     DragDropFuncWrapper::DrawTiledPixelMap(tiledPixelMap, children, pixelMapRect);
666     EXPECT_TRUE(children.empty());
667     children.emplace_back(framenode);
668     children.emplace_back(framenode);
669     for (auto& node : children) {
670         auto gestureHub = node->GetOrCreateGestureEventHub();
671         ASSERT_NE(gestureHub, nullptr);
672         gestureHub->dragPreviewPixelMap_ = tiledPixelMap;
673     }
674     DragDropFuncWrapper::DrawTiledPixelMap(tiledPixelMap, children, pixelMapRect);
675     EXPECT_FALSE(children.empty());
676 }
677 
678 /**
679  * @tc.name: DragEventActuatorUpdatePreviewAttrTest047
680  * @tc.desc: Create DragEventActuator and invoke CreateTiledPixelMap function.
681  * @tc.type: FUNC
682  */
683 HWTEST_F(DragEventTestNg, DragEventActuatorUpdatePreviewAttrTest047, TestSize.Level1)
684 {
685     auto eventHub = AceType::MakeRefPtr<EventHub>();
686     ASSERT_NE(eventHub, nullptr);
687     auto framenode = FrameNode::CreateFrameNode(
688         "test", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), false);
689     ASSERT_NE(framenode, nullptr);
690     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
691     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
692     gestureEventHub->contextMenuShowStatus_ = true;
693     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
694         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
695     ASSERT_NE(dragEventActuator, nullptr);
696     auto getEventTargetImpl = eventHub->CreateGetEventTargetImpl();
697     ASSERT_NE(getEventTargetImpl, nullptr);
698     TouchTestResult finalResult;
699     ResponseLinkResult responseLinkResult;
700     auto focusHub = framenode->GetOrCreateFocusHub();
701     double unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
__anondcb5a0f71402(GestureEvent& info) 702     GestureEventFunc actionStart = [&unknownPropertyValue](GestureEvent& info) {};
__anondcb5a0f71502() 703     GestureEventNoParameter actionCancel = [&unknownPropertyValue]() {};
704     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
705         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
706     dragEventActuator->ReplaceDragEvent(dragEvent);
707     dragEventActuator->SetCustomDragEvent(dragEvent);
708     dragEventActuator->SequencedRecognizer_ = nullptr;
709     auto parentNode = FrameNode::CreateFrameNode(
710         "test", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), false);
711     ASSERT_NE(parentNode, nullptr);
712     dragEventActuator->itemParentNode_ = parentNode;
713     void* voidPtr = static_cast<void*>(new char[0]);
714     RefPtr<PixelMap> tiledPixelMap = PixelMap::CreatePixelMap(voidPtr);
715     ASSERT_NE(tiledPixelMap, nullptr);
716     std::vector<RefPtr<FrameNode>> children;
717     children.emplace_back(framenode);
718     children.emplace_back(framenode);
719     for (auto& node : children) {
720         auto gestureHub = node->GetOrCreateGestureEventHub();
721         ASSERT_NE(gestureHub, nullptr);
722         gestureHub->SetDragPreviewPixelMap(tiledPixelMap);
723     }
724     EXPECT_EQ(DragDropFuncWrapper::GetTiledPixelMapInfo(children), nullptr);
725 }
726 
727 /**
728  * @tc.name: DragEventActuatorDragGestureTest001
729  * @tc.desc: Create DragEventActuator and invoke OnCollectTouchTarget function, then test recognizer callback.
730  * @tc.type: FUNC
731  */
732 HWTEST_F(DragEventTestNg, DragEventActuatorDragGestureTest001, TestSize.Level1)
733 {
734     /**
735      * @tc.steps: step1. create DragEventActuator and collect drag event.
736      */
737     auto eventHub = AceType::MakeRefPtr<EventHub>();
738     ASSERT_NE(eventHub, nullptr);
739     auto frameNode = AceType::MakeRefPtr<FrameNode>(
740         V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>());
741     ASSERT_NE(frameNode, nullptr);
742     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
743     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
744     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
745         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
746     ASSERT_NE(dragEventActuator, nullptr);
747     double unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
748     GestureEventFunc actionStart = [&unknownPropertyValue](
__anondcb5a0f71602( GestureEvent& info) 749                                        GestureEvent& info) { unknownPropertyValue = GESTURE_EVENT_PROPERTY_VALUE; };
750     GestureEventFunc actionLongPress = [&unknownPropertyValue](
__anondcb5a0f71702( GestureEvent& info) 751                                            GestureEvent& info) { unknownPropertyValue = GESTURE_EVENT_PROPERTY_VALUE; };
__anondcb5a0f71802() 752     GestureEventNoParameter actionCancel = [&unknownPropertyValue]() {
753         unknownPropertyValue = GESTURE_EVENT_PROPERTY_VALUE;
754     };
755     auto dragEvent = AceType::MakeRefPtr<DragEvent>(
756         std::move(actionStart), std::move(actionStart), std::move(actionStart), std::move(actionCancel));
757     dragEvent->SetLongPressEventFunc(std::move(actionLongPress));
758     dragEventActuator->ReplaceDragEvent(dragEvent);
759     auto getEventTargetImpl = eventHub->CreateGetEventTargetImpl();
760     TouchTestResult finalResult;
761     ResponseLinkResult responseLinkResult;
762     dragEventActuator->OnCollectTouchTarget(
763         COORDINATE_OFFSET, DRAG_TOUCH_RESTRICT, getEventTargetImpl, finalResult, responseLinkResult);
764     ASSERT_NE(dragEventActuator->panRecognizer_->onActionCancel_, nullptr);
765     ASSERT_NE(dragEventActuator->longPressRecognizer_->onAction_, nullptr);
766     ASSERT_NE(dragEventActuator->SequencedRecognizer_->onActionCancel_, nullptr);
767 
768     auto context = PipelineContext::GetCurrentContext();
769     ASSERT_NE(context, nullptr);
770     context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
771     auto taskExecutor = context->GetTaskExecutor();
772     ASSERT_NE(taskExecutor, nullptr);
773     /**
774      * @tc.steps: step2. call actionCancel function.
775      */
776     GestureEvent info = GestureEvent();
777     (*(dragEventActuator->panRecognizer_->onActionCancel_))(info);
778     EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_DEFAULT_VALUE);
779     frameNode->SetDraggable(false);
780     (*(dragEventActuator->panRecognizer_->onActionCancel_))(info);
781     EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_VALUE);
782     unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
783 
784     /**
785      * @tc.steps: step3. call sequenceCancel function.
786      */
787     dragEventActuator->longPressRecognizer_->refereeState_ = RefereeState::READY;
788     (*(dragEventActuator->SequencedRecognizer_->onActionCancel_))(info);
789     EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_DEFAULT_VALUE);
790     dragEventActuator->longPressRecognizer_->refereeState_ = RefereeState::SUCCEED;
791     (*(dragEventActuator->SequencedRecognizer_->onActionCancel_))(info);
792     EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_VALUE);
793     unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
794 
795     /**
796      * @tc.steps: step3. call longPressAction function.
797      */
798     dragEventActuator->isDragPrepareFinish_ = true;
799     (*(dragEventActuator->longPressRecognizer_->onAction_))(info);
800     EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_DEFAULT_VALUE);
801     dragEventActuator->isDragPrepareFinish_ = false;
802     (*(dragEventActuator->longPressRecognizer_->onAction_))(info);
803     EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_VALUE);
804 }
805 
806 /**
807  * @tc.name: DragEventActuatorMountGatherNodeTest032
808  * @tc.desc: Test UpdateGatherAnimatePosition function.
809  * @tc.type: FUNC
810  */
811 HWTEST_F(DragEventTestNg, DragEventActuatorMountGatherNodeTest032, TestSize.Level1)
812 {
813     /**
814      * @tc.steps: step1. create gatherNodeChildInfo
815      */
816     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anondcb5a0f71902() 817         []() { return AceType::MakeRefPtr<ImagePattern>(); });
818     ASSERT_NE(frameNode, nullptr);
819     auto renderContext = frameNode->GetRenderContext();
820     ASSERT_NE(renderContext, nullptr);
821 
822     /**
823      * @tc.steps: step1. Test UpdateGatherAnimatePosition
824      */
825     std::vector<GatherNodeChildInfo> gatherNodeChildInfo(1);
826     gatherNodeChildInfo[0].imageNode = frameNode;
827     auto tempOffset = OffsetT<Dimension>(Dimension(0.0f), Dimension(0.0f));
828     auto targetOffset = OffsetT<Dimension>(Dimension(COORDINATE_OFFSET.GetX()), Dimension(COORDINATE_OFFSET.GetY()));
829     EXPECT_EQ(renderContext->GetPositionValue(tempOffset), tempOffset);
830     DragEventActuator::UpdateGatherAnimatePosition(
831         gatherNodeChildInfo, { COORDINATE_OFFSET.GetX(), COORDINATE_OFFSET.GetY() });
832     EXPECT_EQ(renderContext->GetPositionValue(tempOffset), targetOffset);
833 }
834 
835 /**
836  * @tc.name: DragEventActuatorRestartDragTaskTest002
837  * @tc.desc: Test RestartDragTask function.
838  * @tc.type: FUNC
839  */
840 HWTEST_F(DragEventTestNg, DragEventActuatorRestartDragTaskTest002, TestSize.Level1)
841 {
842     /**
843      * @tc.steps: step1. Create DragEventActuator.
844      */
845     auto eventHub = AceType::MakeRefPtr<EventHub>();
846     ASSERT_NE(eventHub, nullptr);
847     auto framenode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
848     ASSERT_NE(framenode, nullptr);
849     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
850     auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
851     ASSERT_NE(gestureEventHub, nullptr);
852     auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
853         AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE);
854     ASSERT_NE(dragEventActuator, nullptr);
855 
856     /**
857      * @tc.steps: step2. Execute RestartDragTask when actionStart_ is not null.
858      */
859 
860     auto info = GestureEvent();
861     int unknownPropertyValue = UNKNOWN;
862     dragEventActuator->actionStart_ = [&unknownPropertyValue](
__anondcb5a0f71a02( GestureEvent& gestureInfo) 863                                           GestureEvent& gestureInfo) mutable { unknownPropertyValue++; };
864     dragEventActuator->RestartDragTask(info);
865     ASSERT_NE(unknownPropertyValue, UNKNOWN);
866 
867     /**
868      * @tc.steps: step3. Execute RestartDragTask when OriginUIInputEventType() is AXIS.
869      */
870     info.CopyConvertInfoFrom(ConvertInfo { UIInputEventType::AXIS, UIInputEventType::TOUCH });
871     unknownPropertyValue = UNKNOWN;
872     dragEventActuator->RestartDragTask(info);
873     EXPECT_EQ(unknownPropertyValue, UNKNOWN);
874 
875     /**
876      * @tc.steps: step4. Execute RestartDragTask when InputEventType() is AXIS.
877      */
878     info.CopyConvertInfoFrom(ConvertInfo { UIInputEventType::NONE, UIInputEventType::NONE });
879     info.inputEventType_ = InputEventType::AXIS;
880     unknownPropertyValue = UNKNOWN;
881     dragEventActuator->RestartDragTask(info);
882     EXPECT_EQ(unknownPropertyValue, UNKNOWN);
883 }
884 } // namespace OHOS::Ace::NG