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/gesture_event_hub_test_ng.h"
17
18 #include "test/mock/core/common/mock_container.h"
19 #include "test/mock/core/common/mock_interaction_interface.h"
20
21 #include "core/components_ng/base/view_abstract.h"
22 #include "core/components_ng/pattern/grid/grid_item_pattern.h"
23 #include "core/components_ng/pattern/grid/grid_pattern.h"
24 #include "core/components_ng/pattern/image/image_pattern.h"
25 #include "frameworks/core/components_ng/pattern/text/text_pattern.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS::Ace::NG {
31 namespace {
32 constexpr size_t DEFAULT_CHILD_COUNT = 4;
33 constexpr float GRID_WIDTH = 480.0f;
34 constexpr float GRID_HEIGHT = 800.0f;
35 constexpr float ITEM_WIDTH = 120.0f;
36 constexpr float ITEM_HEIGHT = 200.0f;
37 constexpr double DEFAULT_OFFSET_Y = 5.0;
38
CreateGridNodeWithChild(size_t childCount,const GridItemStyle & gridItemStyle)39 RefPtr<FrameNode> CreateGridNodeWithChild(size_t childCount, const GridItemStyle& gridItemStyle)
40 {
41 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::GRID_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
42 []() {return AceType::MakeRefPtr<GridPattern>(); });
43 ViewAbstract::SetWidth(Referenced::RawPtr(frameNode), CalcLength(GRID_WIDTH));
44 ViewAbstract::SetHeight(Referenced::RawPtr(frameNode), CalcLength(GRID_HEIGHT));
45 std::list<RefPtr<FrameNode>> childNodes;
46
47 for (size_t i = 0; i < childCount; ++i) {
48 auto chidNodeId = ElementRegister::GetInstance()->MakeUniqueId();
49 auto childNode = FrameNode::GetOrCreateFrameNode(V2::GRID_ITEM_ETS_TAG, chidNodeId,
50 [itemStyle = gridItemStyle]() { return AceType::MakeRefPtr<GridItemPattern>(nullptr, itemStyle); });
51 ViewAbstract::SetWidth(Referenced::RawPtr(childNode), CalcLength(ITEM_WIDTH));
52 ViewAbstract::SetHeight(Referenced::RawPtr(childNode), CalcLength(ITEM_HEIGHT));
53 childNode->MountToParent(frameNode);
54 childNodes.emplace_back(childNode);
55 }
56 return frameNode;
57 }
58
CreateRecognizerGroup(const RefPtr<NG::FrameNode> & parentNode)59 RefPtr<NG::NGGestureRecognizer> CreateRecognizerGroup(const RefPtr<NG::FrameNode>& parentNode)
60 {
61 CHECK_NULL_RETURN(parentNode, nullptr);
62 std::list<RefPtr<NGGestureRecognizer>> recognizers;
63 for (const auto& childNode : parentNode->GetChildren()) {
64 auto childFrameNode = AceType::DynamicCast<FrameNode>(childNode);
65 if (childFrameNode) {
66 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
67 clickRecognizer->AttachFrameNode(childFrameNode);
68 recognizers.emplace_back(clickRecognizer);
69 }
70 }
71 auto recognizerGroup = AceType::MakeRefPtr<NG::ParallelRecognizer>(std::move(recognizers));
72 if (recognizerGroup) {
73 recognizerGroup->AttachFrameNode(parentNode);
74 }
75 return recognizerGroup;
76 }
77
ProcessDragItemGroupScene()78 RefPtr<FrameNode> ProcessDragItemGroupScene()
79 {
80 auto gridNode = CreateGridNodeWithChild(DEFAULT_CHILD_COUNT, GridItemStyle::NONE);
81 CHECK_NULL_RETURN(gridNode, nullptr);
82 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
83 CHECK_NULL_RETURN(gestureEventHub, nullptr);
84
85 for (const auto& child : gridNode->GetChildren()) {
86 auto childNode = AceType::DynamicCast<FrameNode>(child);
87 if (!childNode) {
88 continue;
89 }
90 auto itemGestureHub = childNode->GetOrCreateGestureEventHub();
91 if (!itemGestureHub) {
92 continue;
93 }
94 itemGestureHub->InitDragDropEvent();
95 auto itemActuator = itemGestureHub->GetDragEventActuator();
96 if (!itemActuator) {
97 continue;
98 }
99 itemActuator->isSelectedItemNode_ = true;
100 itemActuator->itemParentNode_ = gridNode;
101
102 auto gridItemPattern = childNode->GetPattern<GridItemPattern>();
103 if (!gridItemPattern) {
104 continue;
105 }
106 gridItemPattern->SetSelected(true);
107 }
108 auto gridItem = AceType::DynamicCast<FrameNode>(gridNode->GetChildByIndex(0));
109 CHECK_NULL_RETURN(gridItem, nullptr);
110 auto pattern = gridNode->GetPattern<GridPattern>();
111 CHECK_NULL_RETURN(pattern, nullptr);
112 pattern->info_.endIndex_ = DEFAULT_CHILD_COUNT;
113
114 gestureEventHub->InitDragDropEvent();
115 auto actuator = gestureEventHub->GetDragEventActuator();
116 CHECK_NULL_RETURN(actuator, nullptr);
117 actuator->isSelectedItemNode_ = true;
118 actuator->FindItemParentNode(gridItem);
119 return gridNode;
120 }
121 } // namespace
122
123 /**
124 * @tc.name: GetHitTestModeStr
125 * @tc.desc: Test GetHitTestModeStr001
126 * @tc.type: FUNC
127 */
128 HWTEST_F(GestureEventHubTestNg, GetHitTestModeStr001, TestSize.Level1)
129 {
130 /**
131 * @tc.steps: step1. Create GestureEventHub.
132 * @tc.expected: gestureEventHub is not null.
133 */
134 auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
135 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
136 ASSERT_NE(guestureEventHub, nullptr);
137 auto eventHub = guestureEventHub->eventHub_.Upgrade();
138 auto pipline = PipelineContext::GetCurrentContext();
139 auto EventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
140 EventHub->CancelDragForWeb();
141 string testModeStr;
142 /**
143 * @tc.steps: step1. Calling the GetHitTestModeStr interface
144 * @tc.expected: EventHub ->GetHitTestModeStr() is not equal to nullptr
145 */
146 EXPECT_TRUE(testModeStr != GestureEventHub::GetHitTestModeStr(EventHub));
147 }
148
149 /**
150 * @tc.name: HandleOnDragUpdate001
151 * @tc.desc: Test Functions related with drag
152 * @tc.type: FUNC
153 */
154 HWTEST_F(GestureEventHubTestNg, HandleOnDragUpdate001, TestSize.Level1)
155 {
156 /**
157 * @tc.steps: step1. Create guestureEventHub.
158 * @tc.expected: gestureEventHub is not null.
159 */
160 auto frameNode = FrameNode::CreateFrameNode("MyButton", 102, AceType::MakeRefPtr<Pattern>());
161 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
162 ASSERT_NE(guestureEventHub, nullptr);
163 auto eventHub = guestureEventHub->eventHub_.Upgrade();
164 eventHub->AttachHost(frameNode);
165 ASSERT_NE(eventHub, nullptr);
166
167 auto pipline = PipelineContext::GetCurrentContext();
168 ASSERT_NE(pipline, nullptr);
169
170 /**
171 * @tc.steps: step2. call HandleOnDragStart
172 * case: eventHub->HasOnDragStart() is null
173 * @tc.expected: dragDropProxy_ is null.
174 */
175 GestureEvent info;
176 info.SetSourceDevice(SourceType::MOUSE);
177 guestureEventHub->HandleOnDragStart(info);
178 EXPECT_EQ(guestureEventHub->dragDropProxy_, nullptr);
179 /**
180 * @tc.steps: step3. set OnDragStart for eventHub
181 * after that eventHub->HasOnDragStart() is not null
182 * case: dragDropInfo.customNode is not null
183 */
184 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
__anon063235ab0402(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 185 auto onDragStart = [&customNode](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) {
186 DragDropInfo dragDropInfo;
187 dragDropInfo.customNode = customNode;
188 return dragDropInfo;
189 };
190 eventHub->SetOnDragStart(std::move(onDragStart));
191
192 /**
193 * @tc.steps: step4. call HandleOnDragStart
194 * case: dragDropInfo.customNode is not null
195 * @tc.expected: dragDropProxy_ is null.
196 */
197 guestureEventHub->HandleOnDragStart(info);
198 EXPECT_EQ(guestureEventHub->dragDropProxy_, nullptr);
199
200 /**
201 * @tc.steps: step5. call HandleOnDragEnd
202 * case: eventHub->HasOnDrop() is true
203 * @tc.expected: dragDropProxy_ is null
204 * onDrop has been called, msg1 = CHECK_TAG_1
205 */
206 std::string msg1;
__anon063235ab0502(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 207 auto onDrop = [&msg1](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
208 msg1 = CHECK_TAG_1;
209 };
210 eventHub->SetOnDrop(std::move(onDrop));
211 guestureEventHub->HandleOnDragStart(info);
212 guestureEventHub->HandleOnDragEnd(info);
213 EXPECT_EQ(guestureEventHub->dragDropProxy_, nullptr);
214 EXPECT_EQ(msg1, "HELLO");
215 }
216
217 /**
218 * @tc.name: HandleOnDragUpdate002
219 * @tc.desc: Test Functions related with drag
220 * @tc.type: FUNC
221 */
222 HWTEST_F(GestureEventHubTestNg, HandleOnDragUpdate002, TestSize.Level1)
223 {
224 /**
225 * @tc.steps: step1. create GestureEventHub.
226 * @tc.expected: gestureEventHub is not null.
227 */
228 auto eventHub = AceType::MakeRefPtr<EventHub>();
229 ASSERT_NE(eventHub, nullptr);
230 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
231
232 /**
233 * @tc.steps: step2. update the input parameter attributes.
234 */
235 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
236 DragDropInfo dragDropInfo;
237 dragDropInfo.customNode = customNode;
238 frameNode->SetDragPreview(dragDropInfo);
239
240 eventHub->AttachHost(frameNode);
241 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
242 ASSERT_NE(gestureEventHub, nullptr);
243
__anon063235ab0602(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 244 auto onDragStart = [&customNode](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) {
245 DragDropInfo dragDropInfo;
246 dragDropInfo.customNode = customNode;
247 return dragDropInfo;
248 };
249 eventHub->SetOnDragStart(std::move(onDragStart));
250
251 auto eventManager = AceType::MakeRefPtr<EventManager>();
252 ASSERT_NE(eventManager, nullptr);
253
254 auto pipeline = PipelineContext::GetCurrentContext();
255 pipeline->SetEventManager(eventManager);
256 eventManager->SetLastMoveBeforeUp(false);
257
258 /**
259 * @tc.steps: step3. call HandleOnDragStart with SourceType::MOUSE and InputEventType::TOUCH_SCREEN.
260 * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
261 */
262 GestureEvent gestureEvent;
263 gestureEvent.SetSourceDevice(SourceType::MOUSE);
264 gestureEvent.SetInputEventType(InputEventType::MOUSE_BUTTON);
265 gestureEventHub->HandleOnDragStart(gestureEvent);
266 EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
267 }
268
269 /**
270 * @tc.name: HandleOnDragUpdate003
271 * @tc.desc: Test Functions related with drag
272 * @tc.type: FUNC
273 */
274 HWTEST_F(GestureEventHubTestNg, HandleOnDragUpdate003, TestSize.Level1)
275 {
276 auto frameNode = FrameNode::CreateFrameNode(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
277 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
278 ASSERT_NE(guestureEventHub, nullptr);
279 auto eventHub = guestureEventHub->eventHub_.Upgrade();
280 eventHub->AttachHost(frameNode);
281 ASSERT_NE(eventHub, nullptr);
282
283 auto pipline = PipelineContext::GetCurrentContext();
284 ASSERT_NE(pipline, nullptr);
285
286 pipline->SetupRootElement();
287 pipline->onVisibleAreaChangeNodeIds_.clear();
288 pipline->AddOnAreaChangeNode(frameNode->GetId());
289
290 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
__anon063235ab0702(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 291 auto onDragStart = [&customNode](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) {
292 void* voidPtr = static_cast<void*>(new char[0]);
293 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
294 DragDropInfo dragDropInfo;
295 dragDropInfo.customNode = customNode;
296 return dragDropInfo;
297 };
298 eventHub->SetOnDragStart(std::move(onDragStart));
299
300 GestureEvent info;
301 info.SetSourceDevice(SourceType::MOUSE);
302 info.SetInputEventType(InputEventType::TOUCH_SCREEN);
303 guestureEventHub->HandleOnDragStart(info);
304 EXPECT_EQ(guestureEventHub->dragDropProxy_, nullptr);
305 }
306
307 /**
308 * @tc.name: GestureEventHubTest032
309 * @tc.desc: Test ProcessTouchTestHierarchy
310 * @tc.type: FUNC
311 */
312 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest032, TestSize.Level1)
313 {
314 /**
315 * @tc.steps: step1. Create GestureEventHub.
316 * @tc.expected: gestureEventHub is not null.
317 */
318 auto eventHub = AceType::MakeRefPtr<EventHub>();
319 EXPECT_TRUE(eventHub);
320 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
321 EXPECT_TRUE(gestureEventHub);
322
323 /**
324 * @tc.steps: step2. call ProcessTouchTestHierarchy
325 * case: innerRecognizers & gestureHierarchy_ is empty, current is null
326 * @tc.expected: finalResult is empty
327 */
328 TouchRestrict touchRestrict;
329 std::list<RefPtr<NGGestureRecognizer>> innerTargets;
330 TouchTestResult finalResult;
331 ResponseLinkResult responseLinkResult;
332
333 /**
334 * @tc.steps: step3. call externalExclusiveRecognizer_
335 * case: innerRecognizers & gestureHierarchy_ is empty, current is null
336 * @tc.expected: finalResult is empty
337 */
338 gestureEventHub->externalExclusiveRecognizer_.push_back(nullptr);
339 gestureEventHub->externalParallelRecognizer_.push_back(nullptr);
340 EXPECT_EQ(static_cast<int32_t>(gestureEventHub->externalExclusiveRecognizer_.size()), 1);
341 EXPECT_EQ(static_cast<int32_t>(gestureEventHub->externalParallelRecognizer_.size()), 1);
342
343 /**
344 * @tc.steps: step4. call ProcessTouchTestHierarchy
345 * case: innerRecognizers & gestureHierarchy_ is empty, current is null
346 * @tc.expected: finalResult is empty
347 */
348 gestureEventHub->ProcessTouchTestHierarchy(
349 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, nullptr, responseLinkResult);
350 EXPECT_TRUE(finalResult.empty());
351
352 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1);
353 innerTargets.emplace_back(clickRecognizer);
354
355 gestureEventHub->ProcessTouchTestHierarchy(
356 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, nullptr, responseLinkResult);
357 }
358
359 /**
360 * @tc.name: GetPixelMapScale001
361 * @tc.desc: Test GetPixelMapScale
362 * @tc.type: FUNC
363 */
364 HWTEST_F(GestureEventHubTestNg, GetPixelMapScale001, TestSize.Level1)
365 {
366 /**
367 * @tc.steps: step1. Create GestureEventHub.
368 * @tc.expected: gestureEventHub is not null.
369 */
370 auto eventHub = AceType::MakeRefPtr<EventHub>();
371 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
372 eventHub->AttachHost(frameNode);
373 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
374
375 /**
376 * @tc.steps: step2. construct a dragDropProxy and update gestureEventHub attributes.
377 */
378 constexpr int64_t PROXY_ID_NOT_FIT = 101;
379 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
380 gestureEventHub->dragDropProxy_ = dragDropProxy;
381
382 /**
383 * @tc.steps: step3. call HandleOnDragUpdate with GestureEvent.
384 * @tc.expected: gestureEventHub->dragDropProxy_ is true.
385 */
386 GestureEvent info;
387 gestureEventHub->HandleOnDragUpdate(info);
388
389 /**
390 * @tc.steps: step4. call GetPixelMapScale.
391 * @tc.expected: scale is true.
392 */
393 const int32_t height = 600.0f;
394 const int32_t width = 500.0f;
395 float scale = gestureEventHub->GetPixelMapScale(height, width);
396 EXPECT_TRUE(scale);
397 }
398
399 /**
400 * @tc.name: IsPixelMapNeedScale001
401 * @tc.desc: Test IsPixelMapNeedScale
402 * @tc.type: FUNC
403 */
404 HWTEST_F(GestureEventHubTestNg, IsPixelMapNeedScale001, TestSize.Level1)
405 {
406 /**
407 * @tc.steps: step1. Create guestureEventHub.
408 * @tc.expected: gestureEventHub is not null.
409 */
410 auto frameNode = FrameNode::CreateFrameNode("mybutton", -1, AceType::MakeRefPtr<Pattern>());
411 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
412 ASSERT_NE(guestureEventHub, nullptr);
413 auto eventHub = guestureEventHub->eventHub_.Upgrade();
414 eventHub->AttachHost(frameNode);
415 ASSERT_NE(eventHub, nullptr);
416
417 auto pipline = PipelineContext::GetCurrentContext();
418 ASSERT_NE(pipline, nullptr);
419
420 void* voidPtr2 = static_cast<void*>(new char[0]);
421 RefPtr<PixelMap> pixelMap2 = PixelMap::CreatePixelMap(voidPtr2);
422 guestureEventHub->SetPixelMap(pixelMap2);
423
424 bool result = guestureEventHub->IsPixelMapNeedScale();
425 EXPECT_FALSE(result);
426 }
427
428 /**
429 * @tc.name: GetDragDropInfo001
430 * @tc.desc: Test GetDragDropInfo function.
431 * @tc.type: FUNC
432 */
433 HWTEST_F(GestureEventHubTestNg, GetDragDropInfo001, TestSize.Level1)
434 {
435 /**
436 * @tc.steps: step1. Create GestureEventHub.
437 * @tc.expected: gestureEventHub is not null.
438 */
439 auto eventHub = AceType::MakeRefPtr<EventHub>();
440 EXPECT_TRUE(eventHub);
441 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
442 EXPECT_TRUE(gestureEventHub);
443
444 /**
445 * @tc.steps: step2. set defaultOnDragStart for eventHub
446 */
__anon063235ab0802(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 447 auto defaultOnDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
448 DragDropInfo dragDropInfo;
449 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
450 dragEvent->SetData(unifiedData);
451 dragDropInfo.extraInfo = "default extraInfo";
452 return dragDropInfo;
453 };
454 eventHub->SetDefaultOnDragStart(std::move(defaultOnDragStart));
455
456 /**
457 * @tc.steps: step3. call GetDragDropInfo function
458 * case: textDraggable is false, and component is text
459 * @tc.expected: customNode is null, extraInfo is 'default extraInfo'.
460 */
461 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
462 ASSERT_NE(frameNode, nullptr);
463 GestureEvent info;
464 DragDropInfo dragPreviewInfo;
465 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
466 gestureEventHub->InitDragDropEvent();
467 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
468 auto dragDropInfo = gestureEventHub->GetDragDropInfo(info, frameNode, dragPreviewInfo, dragEvent);
469 EXPECT_FALSE(dragDropInfo.customNode);
470 EXPECT_EQ(dragDropInfo.extraInfo, "default extraInfo");
471
472 /**
473 * @tc.steps: step4. call GetDragDropInfo function
474 * case: textDraggable is true, and component is text
475 * @tc.expected: customNode is null, extraInfo is 'default extraInfo'.
476 */
477 gestureEventHub->SetTextDraggable(true);
478 dragDropInfo = gestureEventHub->GetDragDropInfo(info, frameNode, dragPreviewInfo, dragEvent);
479 EXPECT_FALSE(dragDropInfo.customNode);
480 EXPECT_EQ(dragDropInfo.extraInfo, "default extraInfo");
481
482 /**
483 * @tc.steps: step5. set onDragStart for eventHub
484 */
__anon063235ab0902(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 485 auto onDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
486 DragDropInfo dragDropInfo;
487 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
488 dragEvent->SetData(unifiedData);
489 auto customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
490 dragDropInfo.customNode = customNode;
491 dragDropInfo.extraInfo = "user set extraInfo";
492 return dragDropInfo;
493 };
494 eventHub->SetOnDragStart(std::move(onDragStart));
495
496 /**
497 * @tc.steps: step6. call GetDragDropInfo function
498 * case: textDraggable is true, and component is text
499 * @tc.expected: customNode is null, extraInfo is 'user set extraInfo'.
500 */
501 dragDropInfo = gestureEventHub->GetDragDropInfo(info, frameNode, dragPreviewInfo, dragEvent);
502 EXPECT_FALSE(dragDropInfo.customNode);
503 EXPECT_EQ(dragDropInfo.extraInfo, "user set extraInfo");
504 }
505
506 /**
507 * @tc.name: GetDragDropInfo002
508 * @tc.desc: Test GetDragDropInfo function.
509 * @tc.type: FUNC
510 */
511 HWTEST_F(GestureEventHubTestNg, GetDragDropInfo002, TestSize.Level1)
512 {
513 /**
514 * @tc.steps: step1. Create GestureEventHub.
515 * @tc.expected: gestureEventHub is not null.
516 */
517 auto eventHub = AceType::MakeRefPtr<EventHub>();
518 EXPECT_TRUE(eventHub);
519 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
520 EXPECT_TRUE(gestureEventHub);
521
522 /**
523 * @tc.steps: step2. set onDragStart for eventHub
524 */
__anon063235ab0a02(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 525 auto onDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
526 DragDropInfo dragDropInfo;
527 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
528 dragEvent->SetData(unifiedData);
529 auto customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
530 dragDropInfo.customNode = customNode;
531 dragDropInfo.extraInfo = "user set extraInfo";
532 return dragDropInfo;
533 };
534 eventHub->SetOnDragStart(std::move(onDragStart));;
535
536 /**
537 * @tc.steps: step3. set dragPreview for frameNode
538 */
539 auto frameNode = FrameNode::CreateFrameNode(V2::IMAGE_ETS_TAG, -1, AceType::MakeRefPtr<ImagePattern>());
540 ASSERT_NE(frameNode, nullptr);
541 DragDropInfo dragPreviewDropInfo;
542 dragPreviewDropInfo.extraInfo = "drag preview extraInfo";
543 auto customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
544 dragPreviewDropInfo.customNode = customNode;
545 frameNode->SetDragPreview(dragPreviewDropInfo);
546
547 /**
548 * @tc.steps: step4. call GetDragDropInfo function
549 * case: textDraggable is false, and component is image
550 * @tc.expected: dragPreviewInfo.customNode is not null, extraInfo is 'drag preview extraInfo'.
551 */
552 GestureEvent info;
553 DragDropInfo dragPreviewInfo;
554 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
555 gestureEventHub->InitDragDropEvent();
556 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
557 gestureEventHub->SetTextDraggable(true);
558 info.SetInputEventType(InputEventType::MOUSE_BUTTON);
559 auto dragDropInfo = gestureEventHub->GetDragDropInfo(info, frameNode, dragPreviewInfo, dragEvent);
560 EXPECT_TRUE(dragDropInfo.customNode);
561 EXPECT_EQ(dragDropInfo.extraInfo, "user set extraInfo");
562 EXPECT_TRUE(dragPreviewInfo.customNode);
563 EXPECT_EQ(dragPreviewInfo.extraInfo, "drag preview extraInfo");
564 }
565
566 /**
567 * @tc.name: GetUnifiedData001
568 * @tc.desc: Test GetUnifiedData function when user has not set the onDragStart callback.
569 * @tc.type: FUNC
570 */
571 HWTEST_F(GestureEventHubTestNg, GetUnifiedData001, TestSize.Level1)
572 {
573 /**
574 * @tc.steps: step1. Create GestureEventHub.
575 * @tc.expected: gestureEventHub is not null.
576 */
577 auto eventHub = AceType::MakeRefPtr<EventHub>();
578 EXPECT_TRUE(eventHub);
579 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
580 EXPECT_TRUE(gestureEventHub);
581
582 gestureEventHub->InitDragDropEvent();
583 /**
584 * @tc.steps: step2. set OnDragStart for eventHub
585 * case: user not set onDragStart callback function
586 */
587 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
__anon063235ab0b02(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 588 auto defaultOnDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
589 DragDropInfo dragDropInfo;
590 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
591 dragEvent->SetData(unifiedData);
592 dragDropInfo.extraInfo = "default extraInfo";
593 return dragDropInfo;
594 };
595 eventHub->SetDefaultOnDragStart(std::move(defaultOnDragStart));
596 EXPECT_TRUE(eventHub->GetDefaultOnDragStart());
597
598 /**
599 * @tc.steps: step3. Call GetUnifiedData function
600 * case: Do not set default onDragStart function
601 * @tc.expected: unifiedData is not null, extraInfo is not empty.
602 */
603 DragDropInfo dragDropInfo;
604 gestureEventHub->GetUnifiedData("", dragDropInfo, dragEvent);
605 EXPECT_TRUE(dragEvent->GetData());
606 EXPECT_EQ(dragDropInfo.extraInfo, "default extraInfo");
607
608 /**
609 * @tc.steps: step4. Call GetUnifiedData function
610 * case: Do not set default onDragStart function
611 * @tc.expected: unifiedData is not null, extraInfo is not empty.
612 */
613 dragEvent->SetData(nullptr);
614 dragDropInfo.extraInfo = "";
615 eventHub->SetDefaultOnDragStart(nullptr);
616 gestureEventHub->GetUnifiedData("", dragDropInfo, dragEvent);
617 EXPECT_EQ(dragEvent->GetData(), nullptr);
618 EXPECT_EQ(dragDropInfo.extraInfo, "");
619 }
620
621 /**
622 * @tc.name: GetUnifiedData002
623 * @tc.desc: Test GetUnifiedData function when user set the onDragStart callback.
624 * @tc.type: FUNC
625 */
626 HWTEST_F(GestureEventHubTestNg, GetUnifiedData002, TestSize.Level1)
627 {
628 /**
629 * @tc.steps: step1. Create GestureEventHub.
630 * @tc.expected: gestureEventHub is not null.
631 */
632 auto eventHub = AceType::MakeRefPtr<EventHub>();
633 EXPECT_TRUE(eventHub);
634 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
635 EXPECT_TRUE(gestureEventHub);
636
637 /**
638 * @tc.steps: step2. set OnDragStart for eventHub
639 * case: set user set onDragStart and defaultOnDragStart
640 */
641 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
__anon063235ab0c02(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 642 auto defaultOnDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
643 DragDropInfo dragDropInfo;
644 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
645 dragEvent->SetData(unifiedData);
646 dragDropInfo.extraInfo = "default extraInfo";
647 return dragDropInfo;
648 };
649 eventHub->SetDefaultOnDragStart(std::move(defaultOnDragStart));
650 EXPECT_TRUE(eventHub->GetDefaultOnDragStart());
651
652 /**
653 * @tc.steps: step3. Call GetUnifiedData function
654 * case: user do not set unifiedData and extraInfo
655 * @tc.expected: unifiedData is not null, extraInfo is not empty.
656 */
657 gestureEventHub->InitDragDropEvent();
658 DragDropInfo dragDropInfo;
659 gestureEventHub->GetUnifiedData("", dragDropInfo, dragEvent);
660 EXPECT_TRUE(dragEvent->GetData());
661 EXPECT_EQ(dragDropInfo.extraInfo, "default extraInfo");
662
663 /**
664 * @tc.steps: step4. set OnDragStart for eventHub
665 * case: user set onDragStart function
666 */
667 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
668 dragEvent->SetData(unifiedData);
669 dragDropInfo.extraInfo = "user set extraInfo";
670 eventHub->SetDefaultOnDragStart(std::move(defaultOnDragStart));
671 EXPECT_TRUE(eventHub->GetDefaultOnDragStart());
672
673 /**
674 * @tc.steps: step5. Call GetUnifiedData function
675 * case: user set unifiedData and extraInfo
676 * @tc.expected: unifiedData is not null, extraInfo is not empty.
677 */
678 gestureEventHub->GetUnifiedData("", dragDropInfo, dragEvent);
679 EXPECT_TRUE(dragEvent->GetData());
680 EXPECT_EQ(dragDropInfo.extraInfo, "user set extraInfo");
681 }
682
683 /**
684 * @tc.name: GestureEventHubNodeTest001
685 * @tc.desc: Test SetJSFrameNodeOnClick and ClearJSFrameNodeOnClick.
686 * @tc.type: FUNC
687 */
688 HWTEST_F(GestureEventHubTestNg, GestureEventHubNodeTest001, TestSize.Level1)
689 {
690 /**
691 * @tc.steps: step1. Create GestureEventHub.
692 * @tc.expected: gestureEventHub is not null.
693 */
694 auto eventHub = AceType::MakeRefPtr<EventHub>();
695 EXPECT_TRUE(eventHub);
696 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
697 EXPECT_TRUE(gestureEventHub);
698
699 /**
700 * @tc.steps: step2. Create GestureEventFunc and call SetJSFrameNodeOnClick.
701 * @tc.expected: ClickEventActuator_ is not nullptr.
702 */
__anon063235ab0d02(GestureEvent& info) 703 GestureEventFunc gestureEventFunc = [](GestureEvent& info) {};
704 gestureEventHub->SetJSFrameNodeOnClick(std::move(gestureEventFunc));
705 EXPECT_NE(gestureEventHub->clickEventActuator_, nullptr);
706
707 /**
708 * @tc.steps: step3. Set parallelCombineClick and call SetJSFrameNodeOnClick.
709 * @tc.expected: userParallelClickEventActuator_ is not nullptr.
710 */
711 gestureEventHub->parallelCombineClick = true;
712 gestureEventHub->SetJSFrameNodeOnClick(std::move(gestureEventFunc));
713 EXPECT_NE(gestureEventHub->userParallelClickEventActuator_, nullptr);
714
715 /**
716 * @tc.steps: step4. Call ClearJSFrameNodeOnClick.
717 * @tc.expected: jsFrameNodeCallback_ is nullptr.
718 */
719 gestureEventHub->ClearJSFrameNodeOnClick();
720 EXPECT_EQ(gestureEventHub->clickEventActuator_->jsFrameNodeCallback_, nullptr);
721 }
722
723 /**
724 * @tc.name: GestureEventHubNodeTest002
725 * @tc.desc: Test SetOnTouchEvent, SetJSFrameNodeOnTouchEvent and ClearJSFrameNodeOnClick.
726 * @tc.type: FUNC
727 */
728 HWTEST_F(GestureEventHubTestNg, GestureEventHubNodeTest002, TestSize.Level1)
729 {
730 /**
731 * @tc.steps: step1. Create GestureEventHub.
732 * @tc.expected: gestureEventHub is not null.
733 */
734 auto eventHub = AceType::MakeRefPtr<EventHub>();
735 EXPECT_TRUE(eventHub);
736 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
737 EXPECT_TRUE(gestureEventHub);
738
739 /**
740 * @tc.steps: step2. Create touchEventFunc and call SetOnTouchEvent.
741 * @tc.expected: ouchEventActuator_ is not nullptr.
742 */
__anon063235ab0e02(TouchEventInfo& info) 743 TouchEventFunc touchEventFunc = [](TouchEventInfo& info) {};
744 gestureEventHub->SetOnTouchEvent(std::move(touchEventFunc));
745 gestureEventHub->SetJSFrameNodeOnTouchEvent(std::move(touchEventFunc));
746 EXPECT_NE(gestureEventHub->touchEventActuator_, nullptr);
747
748 /**
749 * @tc.steps: step3. Call ClearJSFrameNodeOnTouch.
750 * @tc.expected: commonTouchEventCallback_ is nullptr.
751 */
752 gestureEventHub->ClearJSFrameNodeOnTouch();
753 EXPECT_EQ(gestureEventHub->touchEventActuator_->commonTouchEventCallback_, nullptr);
754 }
755
756 /**
757 * @tc.name: TestSetDragGatherPixelMap001
758 * @tc.desc: Test SetDragGatherPixelMap.
759 * @tc.type: FUNC
760 */
761 HWTEST_F(GestureEventHubTestNg, TestSetDragGatherPixelMap001, TestSize.Level1)
762 {
763 /**
764 * @tc.steps: step1. Create Grid Node.
765 */
766 auto gridNode = FrameNode::CreateFrameNode(
767 V2::GRID_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
768 ASSERT_NE(gridNode, nullptr);
769 /**
770 * @tc.steps: step2. Create Grid Item Node.
771 */
772 auto gridItemNode1 = FrameNode::CreateFrameNode(
773 V2::GRID_ITEM_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
774 AceType::MakeRefPtr<GridItemPattern>(nullptr, GridItemStyle::NONE));
775 ASSERT_NE(gridItemNode1, nullptr);
776 auto gridItemNode2 = FrameNode::CreateFrameNode(
777 V2::GRID_ITEM_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
778 AceType::MakeRefPtr<GridItemPattern>(nullptr, GridItemStyle::NONE));
779 ASSERT_NE(gridItemNode2, nullptr);
780 auto itemPattern1 = gridItemNode1->GetPattern<GridItemPattern>();
781 ASSERT_NE(itemPattern1, nullptr);
782 itemPattern1->SetSelected(true);
783 auto itemPattern2 = gridItemNode2->GetPattern<GridItemPattern>();
784 ASSERT_NE(itemPattern2, nullptr);
785 itemPattern2->SetSelected(true);
786 NG::DragPreviewOption option { true, false, true };
787 gridItemNode1->SetDragPreviewOptions(option);
788 gridNode->AddChild(gridItemNode1);
789 gridNode->AddChild(gridItemNode2);
790 /**
791 * @tc.steps: step3. Create gestureEventHub and Test SetDragGatherPixelMap.
792 */
793 auto eventHub = AceType::MakeRefPtr<EventHub>();
794 ASSERT_NE(eventHub, nullptr);
795 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
796 ASSERT_NE(gestureEventHub, nullptr);
797 GestureEvent info;
798 info.SetInputEventType(InputEventType::MOUSE_BUTTON);
799 gestureEventHub->SetDragGatherPixelMaps(info);
800 /**
801 * @tc.steps: step4. Get DragDropManager.
802 */
803 auto pipeline = PipelineContext::GetMainPipelineContext();
804 auto dragDropManager = pipeline->GetDragDropManager();
805 ASSERT_NE(dragDropManager, nullptr);
806 /**
807 * @tc.steps: step5. Test SetDragGatherPixelMap result.
808 */
809 DragDataCore dragData;
810 dragDropManager->GetGatherPixelMap(dragData, 1.0f);
811 auto size = dragData.shadowInfos.size();
812 EXPECT_EQ(size, 0);
813 }
814
815 /**
816 * @tc.name: GestureEventHubModifierTest001
817 * @tc.desc: Test modifier AttachGesture & RemoveGesture & ClearModifierGesture
818 * @tc.type: FUNC
819 */
820 HWTEST_F(GestureEventHubTestNg, GestureEventHubModifierTest001, TestSize.Level1)
821 {
822 /**
823 * @tc.steps: step1. Create GestureEventHub.
824 * @tc.expected: gestureEventHub is not null.
825 */
826 auto eventHub = AceType::MakeRefPtr<EventHub>();
827 EXPECT_TRUE(eventHub);
828 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
829 eventHub->AttachHost(frameNode);
830 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
831 EXPECT_TRUE(gestureEventHub);
832
833 /**
834 * @tc.steps: step2. call AttachGesture
835 * case: recreateGesture_ is true & modifierGestures_.size() != gestureHierarchy_.size()
836 * @tc.expected: modifierGestures_ has one element & gestureHierarchy_ has zero element
837 */
838 auto longPressGesture = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
839 gestureEventHub->AttachGesture(longPressGesture);
840 auto sizeModifierGestures = static_cast<int32_t>(gestureEventHub->modifierGestures_.size());
841 auto sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
842 EXPECT_EQ(sizeModifierGestures, 1);
843 EXPECT_EQ(sizeGestureHierarchy, 0);
844
845 /**
846 * @tc.steps: step3. call RemoveGesture
847 * case: recreateGesture_ is true & modifierGestures_.size() != gestureHierarchy_.size()
848 * @tc.expected: modifierGestures_ has zero element & gestureHierarchy_ has zero element
849 */
850 gestureEventHub->RemoveGesture(longPressGesture);
851 sizeModifierGestures = static_cast<int32_t>(gestureEventHub->modifierGestures_.size());
852 sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
853 EXPECT_EQ(sizeModifierGestures, 0);
854 EXPECT_EQ(sizeGestureHierarchy, 0);
855
856 /**
857 * @tc.steps: step4. call AttachGesture & ClearModifierGesture
858 * case: recreateGesture_ is true & gestures_.size() != gestureHierarchy_.size()
859 * @tc.expected: modifierGestures_ has cleared & gestureHierarchy_ has cleared
860 */
861 gestureEventHub->AttachGesture(longPressGesture);
862 sizeModifierGestures = static_cast<int32_t>(gestureEventHub->modifierGestures_.size());
863 sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
864 EXPECT_EQ(sizeModifierGestures, 1);
865 EXPECT_EQ(sizeGestureHierarchy, 0);
866
867 gestureEventHub->ClearModifierGesture();
868 sizeModifierGestures = static_cast<int32_t>(gestureEventHub->modifierGestures_.size());
869 sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
870 EXPECT_EQ(sizeModifierGestures, 0);
871 EXPECT_EQ(sizeGestureHierarchy, 0);
872 }
873
874 /**
875 * @tc.name: GestureEventHubModifierTest002
876 * @tc.desc: Test modifier RemoveGesturesByTag
877 * @tc.type: FUNC
878 */
879 HWTEST_F(GestureEventHubTestNg, GestureEventHubModifierTest002, TestSize.Level1)
880 {
881 /**
882 * @tc.steps: step1. Create GestureEventHub.
883 * @tc.expected: gestureEventHub is not null.
884 */
885 auto eventHub = AceType::MakeRefPtr<EventHub>();
886 EXPECT_TRUE(eventHub);
887 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
888 eventHub->AttachHost(frameNode);
889 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
890 EXPECT_TRUE(gestureEventHub);
891
892 /**
893 * @tc.steps: step4. call RemoveGesturesByTag
894 * @tc.expected: modifierGestures_ one element & gestureHierarchy_ has zero element & group has one child
895 */
896 std::vector<RefPtr<Gesture>> gestures;
897 auto longPressGestureOne = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
898 longPressGestureOne->SetTag(CHECK_TAG_1);
899 gestures.emplace_back(longPressGestureOne);
900 auto longPressGestureTwo = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
901 gestures.emplace_back(longPressGestureTwo);
902 auto group = AceType::MakeRefPtr<GestureGroup>(GestureMode::Exclusive, gestures);
903 gestureEventHub->AttachGesture(group);
904 auto sizeModifierGestures = static_cast<int32_t>(gestureEventHub->modifierGestures_.size());
905 auto sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
906 EXPECT_EQ(sizeModifierGestures, 1);
907 EXPECT_EQ(sizeGestureHierarchy, 0);
908
909 gestureEventHub->RemoveGesturesByTag(CHECK_TAG_1);
910 sizeModifierGestures = static_cast<int32_t>(gestureEventHub->modifierGestures_.size());
911 sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
912 EXPECT_EQ(sizeModifierGestures, 1);
913 EXPECT_EQ(sizeGestureHierarchy, 0);
914 EXPECT_EQ(group->gestures_.size(), 1);
915 }
916
917
918 /**
919 * @tc.name: GestureEventHubTest033
920 * @tc.desc: Test ClickEventActuator AddClickAfterEvent.
921 * @tc.type: FUNC
922 */
923 HWTEST_F(GestureEventHubTestNg, GestureEventHubTest033, TestSize.Level1)
924 {
925 /**
926 * @tc.steps: step1. Create GestureEventHub.
927 * @tc.expected: gestureEventHub is not null.
928 */
929 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
930 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
931 ASSERT_NE(guestureEventHub, nullptr);
932
__anon063235ab0f02(GestureEvent& info) 933 auto clickCallback = [](GestureEvent& info) {};
934 auto clickEvent = AceType::MakeRefPtr<ClickEvent>(std::move(clickCallback));
935 guestureEventHub->AddClickAfterEvent(clickEvent);
936 EXPECT_NE(guestureEventHub->GetClickEvent(), nullptr);
937 }
938
939 /**
940 * @tc.name: UpdateExtraInfoTest001
941 * @tc.desc: Test UpdateExtraInfo function
942 * @tc.type: FUNC
943 */
944 HWTEST_F(GestureEventHubTestNg, UpdateExtraInfoTest001, TestSize.Level1)
945 {
946 /**
947 * @tc.steps: step1. create frameNode、guestureEventHub.DragPreviewOption
948 */
949 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
950 Dimension dimen(2.0);
951 BlurBackGroundInfo bgBackEffect = {{dimen, 1.0f, 1.0f, Color::TRANSPARENT,
952 AdaptiveColor::DEFAULT, {{2.0f, 2.0f}}}};
953 std::optional<Shadow> shadowVal;
954 std::optional<BorderRadiusProperty> borderRadiusVal;
955 OptionsAfterApplied optionTmp = {0, shadowVal, "test", true, borderRadiusVal, {bgBackEffect}};
956 DragPreviewOption dragPreviewInfos;
957 dragPreviewInfos.options = optionTmp;
958 frameNode->SetDragPreviewOptions(dragPreviewInfos);
959 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
960 /**
961 * @tc.steps: step2. Test UpdateExtraInfo
962 */
963 auto arkExtraInfoJson = JsonUtil::Create(true);
964 PreparedInfoForDrag data;
965 guestureEventHub->UpdateExtraInfo(frameNode, arkExtraInfoJson, 1.0f, data);
966 auto radiusJs = arkExtraInfoJson->GetDouble("blur_radius", -1);
967 EXPECT_EQ(radiusJs, 2.0);
968 /**
969 * @tc.steps: step3. Test UpdateExtraInfo invalid
970 */
971 dragPreviewInfos.options.blurbgEffect.backGroundEffect.radius.SetValue(0);
972 frameNode->SetDragPreviewOptions(dragPreviewInfos);
973 auto jsInfos = JsonUtil::Create(true);
974 guestureEventHub->UpdateExtraInfo(frameNode, jsInfos, 1.0f, data);
975 radiusJs = jsInfos->GetDouble("blur_radius", -1);
976 EXPECT_EQ(radiusJs, -1);
977 }
978
979 /**
980 * @tc.name: GestureEventHubAddGestureToGestureHierarchyTest001
981 * @tc.desc: Test AddGestureToGestureHierarchy.
982 * @tc.type: FUNC
983 */
984 HWTEST_F(GestureEventHubTestNg, GestureEventHubAddGestureToGestureHierarchyTest001, TestSize.Level1)
985 {
986 /**
987 * @tc.steps: step1. Create GestureEventHub.
988 * @tc.expected: gestureEventHub is not null.
989 */
990 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
991 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
992 ASSERT_NE(guestureEventHub, nullptr);
993
994 /**
995 * @tc.steps: step2. Invoke AddGestureToGestureHierarchy.
996 * @tc.expected: gesture is null.
997 */
998 guestureEventHub->AddGestureToGestureHierarchy(nullptr, false);
999 }
1000
1001 /**
1002 * @tc.name: GestureEventHubGetPixelMapScaleTest001
1003 * @tc.desc: Test GetPixelMapScale.
1004 * @tc.type: FUNC
1005 */
1006 HWTEST_F(GestureEventHubTestNg, GestureEventHubGetPixelMapScaleTest001, TestSize.Level1)
1007 {
1008 /**
1009 * @tc.steps: step1. Create GestureEventHub.
1010 * @tc.expected: gestureEventHub is not null.
1011 */
1012 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
1013 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1014 ASSERT_NE(guestureEventHub, nullptr);
1015
1016 /**
1017 * @tc.steps: step2. Invoke GetPixelMapScale.
1018 * @tc.expected: height is 1 and width is 0.
1019 */
1020 auto scale = guestureEventHub->GetPixelMapScale(1, 0);
1021 EXPECT_EQ(scale, 1.0f);
1022
1023 /**
1024 * @tc.steps: step2. Invoke GetPixelMapScale.
1025 * @tc.expected: height is 1 and width is 0.
1026 */
1027 scale = guestureEventHub->GetPixelMapScale(0, 1);
1028 EXPECT_EQ(scale, 1.0f);
1029 }
1030
1031 /**
1032 * @tc.name: GestureEventHubGenerateMousePixelMapTest001
1033 * @tc.desc: Test GenerateMousePixelMap.
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(GestureEventHubTestNg, GestureEventHubGenerateMousePixelMapTest001, TestSize.Level1)
1037 {
1038 /**
1039 * @tc.steps: step1. Create GestureEventHub.
1040 * @tc.expected: gestureEventHub is not null.
1041 */
1042 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
1043 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1044 ASSERT_NE(guestureEventHub, nullptr);
1045
1046 /**
1047 * @tc.steps: step2. Invoke GenerateMousePixelMap.
1048 * @tc.expected: TextDraggable is true.
1049 */
1050 GestureEvent info = GestureEvent();
1051 auto frameNode2 = guestureEventHub->GetFrameNode();
1052 ASSERT_NE(frameNode2, nullptr);
1053 EXPECT_EQ(guestureEventHub->pixelMap_, nullptr);
1054 guestureEventHub->SetTextDraggable(true);
1055 guestureEventHub->GenerateMousePixelMap(info);
1056 EXPECT_EQ(guestureEventHub->pixelMap_, 0);
1057
1058 /**
1059 * @tc.steps: step3. Invoke GenerateMousePixelMap.
1060 * @tc.expected: TextDraggable is false.
1061 */
1062 guestureEventHub->pixelMap_ = nullptr;
1063 guestureEventHub->SetTextDraggable(false);
1064 guestureEventHub->GenerateMousePixelMap(info);
1065 EXPECT_EQ(guestureEventHub->pixelMap_, 0);
1066 }
1067
1068 /**
1069 * @tc.name: GestureEventHubCopyEventTest001
1070 * @tc.desc: Test CopyEvent.
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F(GestureEventHubTestNg, GestureEventHubCopyEventTest001, TestSize.Level1)
1074 {
1075 /**
1076 * @tc.steps: step1. Create GestureEventHub.
1077 * @tc.expected: gestureEventHub is not null.
1078 */
1079 auto eventHub1 = AceType::MakeRefPtr<EventHub>();
1080 ASSERT_NE(eventHub1, nullptr);
1081 auto framenode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
1082 ASSERT_NE(framenode, nullptr);
1083 eventHub1->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
1084 auto gestureEventHub1 = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub1)));
1085 ASSERT_NE(gestureEventHub1, nullptr);
1086 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
1087 AceType::WeakClaim(AceType::RawPtr(gestureEventHub1)), DRAG_DIRECTION, FINGERS_NUMBER, DRAG_DISTANCE);
1088 ASSERT_NE(dragEventActuator, nullptr);
1089
1090 auto eventHub2 = AceType::MakeRefPtr<EventHub>();
1091 ASSERT_NE(eventHub2, nullptr);
1092 auto gestureEventHub2 = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub2)));
1093 ASSERT_NE(gestureEventHub2, nullptr);
1094
1095 /**
1096 * @tc.steps: step2. Invoke CopyEvent.
1097 */
1098 gestureEventHub2->CopyEvent(gestureEventHub1);
1099 EXPECT_FALSE(gestureEventHub1->touchEventActuator_);
1100 EXPECT_FALSE(gestureEventHub1->clickEventActuator_);
1101 EXPECT_FALSE(gestureEventHub1->longPressEventActuator_);
1102 EXPECT_FALSE(gestureEventHub1->dragEventActuator_);
1103 EXPECT_FALSE(gestureEventHub1->showMenu_);
1104
1105 /**
1106 * @tc.steps: step3. Invoke CopyEvent.
1107 */
1108 gestureEventHub1->touchEventActuator_ = AceType::MakeRefPtr<TouchEventActuator>();
1109 EXPECT_NE(gestureEventHub1->touchEventActuator_, nullptr);
1110 gestureEventHub1->clickEventActuator_ = AceType::MakeRefPtr<ClickEventActuator>(gestureEventHub1);
1111 EXPECT_NE(gestureEventHub1->clickEventActuator_, nullptr);
1112 gestureEventHub1->longPressEventActuator_ = AceType::MakeRefPtr<LongPressEventActuator>(gestureEventHub1);
1113 EXPECT_NE(gestureEventHub1->longPressEventActuator_, nullptr);
1114 gestureEventHub1->dragEventActuator_ = dragEventActuator;
1115 EXPECT_NE(gestureEventHub1->dragEventActuator_, nullptr);
__anon063235ab1002(GestureEvent& info) 1116 GestureEventFunc callback = [](GestureEvent& info) {};
1117 gestureEventHub1->showMenu_ = AceType::MakeRefPtr<ClickEvent>(std::move(callback));
1118 EXPECT_NE(gestureEventHub1->showMenu_, nullptr);
1119 EXPECT_FALSE(gestureEventHub2->showMenu_);
1120 gestureEventHub2->CopyEvent(gestureEventHub1);
1121 EXPECT_TRUE(gestureEventHub2->showMenu_);
1122
1123 /**
1124 * @tc.steps: step4. Invoke CopyEvent.
1125 */
1126 gestureEventHub2->showMenu_ = AceType::MakeRefPtr<ClickEvent>(std::move(callback));
1127 gestureEventHub2->CopyEvent(gestureEventHub1);
1128 EXPECT_TRUE(gestureEventHub2->showMenu_);
1129 }
1130
1131 /**
1132 * @tc.name: GestureEventHubIsNeedSwitchToSubWindowTest001
1133 * @tc.desc: Test IsNeedSwitchToSubWindow.
1134 * @tc.type: FUNC
1135 */
1136 HWTEST_F(GestureEventHubTestNg, GestureEventHubIsNeedSwitchToSubWindowTest001, TestSize.Level1)
1137 {
1138 /**
1139 * @tc.steps: step1. Create GestureEventHub.
1140 * @tc.expected: gestureEventHub is not null.
1141 */
1142 auto frameNode1 = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
1143 auto gestureEventHub = frameNode1->GetOrCreateGestureEventHub();
1144 ASSERT_NE(gestureEventHub, nullptr);
1145
1146 /**
1147 * @tc.steps: step2. Invoke IsNeedSwitchToSubWindow.
1148 * @tc.expected: gestureEventHub->IsPixelMapNeedScale() is false.
1149 */
1150 auto frameNode2 = gestureEventHub->GetFrameNode();
1151 EXPECT_NE(frameNode2, nullptr);
1152 frameNode2->GetOrCreateFocusHub();
1153 auto focusHub = frameNode2->GetFocusHub();
1154 EXPECT_NE(focusHub, nullptr);
1155 PreparedInfoForDrag data;
1156 gestureEventHub->IsNeedSwitchToSubWindow(data);
1157 EXPECT_FALSE(gestureEventHub->IsPixelMapNeedScale());
1158 }
1159
1160 /**
1161 * @tc.name: GestureEventHubSetDragGatherPixelMapsTest001
1162 * @tc.desc: Test SetDragGatherPixelMaps.
1163 * @tc.type: FUNC
1164 */
1165 HWTEST_F(GestureEventHubTestNg, GestureEventHubSetDragGatherPixelMapsTest001, TestSize.Level1)
1166 {
1167 /**
1168 * @tc.steps: step1. Create GestureEventHub and DragEventActuator.
1169 * @tc.expected: dragEventActuator and gestureEventHub is not null.
1170 */
1171 auto eventHub = AceType::MakeRefPtr<EventHub>();
1172 ASSERT_NE(eventHub, nullptr);
1173 auto framenode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
1174 ASSERT_NE(framenode, nullptr);
1175 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
1176 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
1177 ASSERT_NE(gestureEventHub, nullptr);
1178 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
1179 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DRAG_DISTANCE);
1180 ASSERT_NE(dragEventActuator, nullptr);
1181
1182 /**
1183 * @tc.steps: step2. Invoke SetDragGatherPixelMaps.
1184 */
1185 GestureEvent info = GestureEvent();
1186 gestureEventHub->dragEventActuator_ = dragEventActuator;
1187 gestureEventHub->SetDragGatherPixelMaps(info);
1188 EXPECT_TRUE(!dragEventActuator->IsNeedGather());
1189 }
1190
1191 /**
1192 * @tc.name: GestureEventHubGetSelectItemSizeTest001
1193 * @tc.desc: Test GetSelectItemSize.
1194 * @tc.type: FUNC
1195 */
1196 HWTEST_F(GestureEventHubTestNg, GestureEventHubGetSelectItemSizeTest001, TestSize.Level1)
1197 {
1198 /**
1199 * @tc.steps: step1. Create GestureEventHub and DragEventActuator.
1200 * @tc.expected: dragEventActuator and gestureEventHub is not null.
1201 */
1202 auto eventHub = AceType::MakeRefPtr<EventHub>();
1203 ASSERT_NE(eventHub, nullptr);
1204 auto framenode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
1205 ASSERT_NE(framenode, nullptr);
1206 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
1207 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
1208 ASSERT_NE(gestureEventHub, nullptr);
1209 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>(
1210 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DRAG_DISTANCE);
1211 ASSERT_NE(dragEventActuator, nullptr);
1212
1213 /**
1214 * @tc.steps: step2. Invoke GetSelectItemSize.
1215 */
1216 gestureEventHub->dragEventActuator_ = dragEventActuator;
1217 gestureEventHub->GetSelectItemSize();
1218 EXPECT_TRUE(!gestureEventHub->dragEventActuator_->IsNeedGather());
1219 }
1220
1221 /**
1222 * @tc.name: GestureEventHubNodeTest003
1223 * @tc.desc: Test SetOnTouchEvent, SetJSFrameNodeOnTouchEvent and ClearJSFrameNodeOnTouch.
1224 * @tc.type: FUNC
1225 */
1226 HWTEST_F(GestureEventHubTestNg, GestureEventHubNodeTest003, TestSize.Level1)
1227 {
1228 /**
1229 * @tc.steps: step1. Create GestureEventHub.
1230 * @tc.expected: gestureEventHub is not null.
1231 */
1232 auto eventHub = AceType::MakeRefPtr<EventHub>();
1233 EXPECT_TRUE(eventHub);
1234 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1235 EXPECT_TRUE(gestureEventHub);
1236
1237 /**
1238 * @tc.steps: step2. Create touchEventFunc and call SetOnTouchEvent.
1239 * @tc.expected: TouchEventActuator_ is nullptr.
1240 */
__anon063235ab1102(TouchEventInfo& info) 1241 TouchEventFunc touchEventFunc = [](TouchEventInfo& info) {};
1242 gestureEventHub->touchEventActuator_ = AceType::MakeRefPtr<TouchEventActuator>();
1243 gestureEventHub->SetOnTouchEvent(std::move(touchEventFunc));
1244 gestureEventHub->touchEventActuator_ = nullptr;
1245 gestureEventHub->SetOnTouchEvent(std::move(touchEventFunc));
1246 gestureEventHub->SetJSFrameNodeOnTouchEvent(std::move(touchEventFunc));
1247 gestureEventHub->ClearJSFrameNodeOnTouch();
1248 EXPECT_NE(gestureEventHub->touchEventActuator_, nullptr);
1249 }
1250
1251 /**
1252 * @tc.name: GestureEventHubNodeTest004
1253 * @tc.desc: ClearJSFrameNodeOnClick.
1254 * @tc.type: FUNC
1255 */
1256 HWTEST_F(GestureEventHubTestNg, GestureEventHubNodeTest004, TestSize.Level1)
1257 {
1258 /**
1259 * @tc.steps: step1. Create GestureEventHub.
1260 * @tc.expected: gestureEventHub is not null.
1261 */
1262 auto eventHub = AceType::MakeRefPtr<EventHub>();
1263 EXPECT_TRUE(eventHub);
1264 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
1265 EXPECT_TRUE(gestureEventHub);
1266
1267 /**
1268 * @tc.steps: step2. Call ClearJSFrameNodeOnClick.
1269 * @tc.expected: clickEventActuator_ is nullptr.
1270 */
1271 gestureEventHub->ClearJSFrameNodeOnClick();
1272 EXPECT_FALSE(gestureEventHub->clickEventActuator_);
1273 }
1274
1275 /**
1276 * @tc.name: HandleOnDragUpdate004
1277 * @tc.desc: Test Functions related with drag
1278 * @tc.type: FUNC
1279 */
1280 HWTEST_F(GestureEventHubTestNg, HandleOnDragUpdate004, TestSize.Level1)
1281 {
1282 /**
1283 * @tc.steps: step1. Create gestureEventHub.
1284 * @tc.expected: gestureEventHub is not null.
1285 */
1286 auto frameNode = FrameNode::CreateFrameNode("MyButton", 102, AceType::MakeRefPtr<Pattern>());
1287 auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
1288 ASSERT_NE(gestureEventHub, nullptr);
1289 auto eventHub = gestureEventHub->eventHub_.Upgrade();
1290 eventHub->AttachHost(frameNode);
1291 ASSERT_NE(eventHub, nullptr);
1292
1293 auto pipeline = PipelineContext::GetCurrentContext();
1294 ASSERT_NE(pipeline, nullptr);
1295
1296 /**
1297 * @tc.steps: step2. call HandleOnDragUpdate
1298 * @tc.expected: dragDropProxy_ is not null.
1299 */
1300 constexpr int64_t PROXY_ID_NOT_FIT = 101;
1301 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
1302 gestureEventHub->dragDropProxy_ = dragDropProxy;
1303 GestureEvent info;
1304 auto dragDropManager = pipeline->GetDragDropManager();
1305 ASSERT_NE(dragDropManager, nullptr);
1306 dragDropManager->isDragged_ = true;
1307 gestureEventHub->HandleOnDragUpdate(info);
1308 EXPECT_TRUE(dragDropManager->IsDragged());
1309 }
1310
1311 /**
1312 * @tc.name: GestureEventHubGetPixelMapOffset001
1313 * @tc.desc: Test GetPixelMapOffset
1314 * @tc.type: FUNC
1315 */
1316 HWTEST_F(GestureEventHubTestNg, GestureEventHubGetPixelMapOffset001, TestSize.Level1)
1317 {
1318 /**
1319 * @tc.steps: step1. Create gestureEventHub.
1320 * @tc.expected: gestureEventHub is not null.
1321 */
1322 auto frameNode1 = FrameNode::CreateFrameNode("MyButton", 102, AceType::MakeRefPtr<Pattern>());
1323 auto gestureEventHub = frameNode1->GetOrCreateGestureEventHub();
1324 ASSERT_NE(gestureEventHub, nullptr);
1325 auto eventHub = gestureEventHub->eventHub_.Upgrade();
1326 eventHub->AttachHost(frameNode1);
1327 ASSERT_NE(eventHub, nullptr);
1328
1329 /**
1330 * @tc.steps2: Invoke GetPixelMapOffset
1331 * @tc.expected: NearZero(gestureEventHub->frameNodeSize_.Width()) is true,
1332 * NearZero(size.Width()) is false.
1333 */
1334 constexpr float PIXELMAP_WIDTH_RATE = -0.5f;
1335 constexpr float PIXELMAP_HEIGHT_RATE = -0.2f;
1336 GestureEvent info = GestureEvent();
1337 auto size = SizeF(1, 1);
1338 PreparedInfoForDrag data;
1339 gestureEventHub->GetPixelMapOffset(info, size, data, 1.0f);
1340 auto frameNode2 = gestureEventHub->GetFrameNode();
1341 EXPECT_NE(frameNode2, nullptr);
1342 OffsetF result = OffsetF(size.Width() * PIXELMAP_WIDTH_RATE, size.Height() * PIXELMAP_HEIGHT_RATE);
1343 EXPECT_TRUE(NearZero(gestureEventHub->frameNodeSize_.Width()));
1344 EXPECT_FALSE(NearZero(size.Width()));
1345 EXPECT_FALSE(result.GetX() >= 0.0f);
1346 EXPECT_FALSE(result.GetX() + size.Width() <= 0.0f);
1347 EXPECT_FALSE(result.GetY() >= 0.0f);
1348 EXPECT_FALSE(result.GetY() + size.Height() <= 0.0f);
1349
1350 /**
1351 * @tc.steps3: Invoke GetPixelMapOffset
1352 * @tc.expected: NearZero(gestureEventHub->frameNodeSize_.Width()) is true,
1353 * NearZero(size.Width()) is true.
1354 */
1355 size = SizeF(0, 0);
1356 gestureEventHub->GetPixelMapOffset(info, size, data, 1.0f);
1357 result = OffsetF(size.Width() * PIXELMAP_WIDTH_RATE, size.Height() * PIXELMAP_HEIGHT_RATE);
1358 EXPECT_TRUE(NearZero(gestureEventHub->frameNodeSize_.Width()));
1359 EXPECT_TRUE(NearZero(size.Width()));
1360 EXPECT_TRUE(result.GetX() >= 0.0f);
1361 EXPECT_TRUE(result.GetX() + size.Width() <= 0.0f);
1362 EXPECT_TRUE(result.GetY() >= 0.0f);
1363 EXPECT_TRUE(result.GetY() + size.Height() <= 0.0f);
1364
1365 /**
1366 * @tc.steps4: Invoke GetPixelMapOffset
1367 * @tc.expected: NearZero(gestureEventHub->frameNodeSize_.Width()) is false,
1368 * NearZero(size.Width()) is false.
1369 */
1370 size = SizeF(500, 600);
1371 gestureEventHub->frameNodeSize_ = SizeF(1, 1);
1372 gestureEventHub->GetPixelMapOffset(info, size, data, 1.0f);
1373 result = OffsetF(size.Width() * PIXELMAP_WIDTH_RATE, size.Height() * PIXELMAP_HEIGHT_RATE);
1374 EXPECT_FALSE(NearZero(gestureEventHub->frameNodeSize_.Width()));
1375 EXPECT_FALSE(NearZero(size.Width()));
1376
1377 /**
1378 * @tc.steps5: Invoke GetPixelMapOffset
1379 * @tc.expected: NearZero(gestureEventHub->frameNodeSize_.Width()) is false,
1380 * NearZero(size.Width()) is true.
1381 */
1382 size = SizeF(0, 0);
1383 gestureEventHub->frameNodeSize_ = SizeF(1, 1);
1384 gestureEventHub->GetPixelMapOffset(info, size, data, 1.0f);
1385 result = OffsetF(size.Width() * PIXELMAP_WIDTH_RATE, size.Height() * PIXELMAP_HEIGHT_RATE);
1386 EXPECT_FALSE(NearZero(gestureEventHub->frameNodeSize_.Width()));
1387 EXPECT_TRUE(NearZero(size.Width()));
1388 }
1389
1390 /**
1391 * @tc.name: GestureEventHubGetPixelMapScaleTest002
1392 * @tc.desc: Test GetPixelMapScale
1393 * @tc.type: FUNC
1394 */
1395 HWTEST_F(GestureEventHubTestNg, GestureEventHubGetPixelMapScaleTest002, TestSize.Level1)
1396 {
1397 /**
1398 * @tc.steps: step1. Create gestureEventHub.
1399 * @tc.expected: gestureEventHub is not null.
1400 */
1401 auto frameNode1 = FrameNode::CreateFrameNode(V2::WEB_ETS_TAG, 102, AceType::MakeRefPtr<Pattern>());
1402 auto gestureEventHub = frameNode1->GetOrCreateGestureEventHub();
1403 ASSERT_NE(gestureEventHub, nullptr);
1404 auto eventHub = gestureEventHub->eventHub_.Upgrade();
1405 eventHub->AttachHost(frameNode1);
1406 ASSERT_NE(eventHub, nullptr);
1407
1408 /**
1409 * @tc.steps2: Invoke GetPixelMapScale
1410 */
1411 int32_t height = 500;
1412 int32_t width = 600;
1413 GestureEvent info = GestureEvent();
1414 auto size = SizeF(1, 1);
1415 PreparedInfoForDrag data;
1416 gestureEventHub->GetPixelMapOffset(info, size, data, 1.0f);
1417 auto frameNode2 = gestureEventHub->GetFrameNode();
1418 EXPECT_NE(frameNode2, nullptr);
1419 auto pipeline = PipelineContext::GetCurrentContext();
1420 EXPECT_NE(pipeline, nullptr);
1421 auto dragDropManager = pipeline->GetDragDropManager();
1422 EXPECT_NE(dragDropManager, nullptr);
1423 auto dragPreviewOption = frameNode2->GetDragPreviewOption();
1424 dragPreviewOption.isScaleEnabled = true;
1425 gestureEventHub->GetPixelMapScale(height, width);
1426 EXPECT_FALSE(!frameNode2->GetDragPreviewOption().isScaleEnabled);
1427 EXPECT_FALSE(!(frameNode2->GetTag() == V2::WEB_ETS_TAG));
1428
1429 /**
1430 * @tc.steps3: Invoke GetPixelMapScale
1431 */
1432 constexpr float PIXELMAP_DEFALUT_LIMIT_SCALE = 0.5f;
1433 SystemProperties::SetDevicePhysicalHeight(600);
1434 SystemProperties::SetDevicePhysicalWidth(200);
1435 int32_t deviceHeight = SystemProperties::GetDevicePhysicalHeight();
1436 int32_t deviceWidth = SystemProperties::GetDevicePhysicalWidth();
1437 int32_t maxDeviceLength = std::max(deviceHeight, deviceWidth);
1438 int32_t minDeviceLength = std::min(deviceHeight, deviceWidth);
1439 gestureEventHub->GetPixelMapScale(height, width);
1440 EXPECT_TRUE(maxDeviceLength * PIXELMAP_DEFALUT_LIMIT_SCALE > minDeviceLength);
1441 EXPECT_TRUE(height > minDeviceLength * PIXELMAP_DEFALUT_LIMIT_SCALE);
1442
1443 /**
1444 * @tc.steps4: Invoke GetPixelMapScale
1445 */
1446 height = 50;
1447 SystemProperties::SetDevicePhysicalHeight(600);
1448 SystemProperties::SetDevicePhysicalWidth(200);
1449 deviceHeight = SystemProperties::GetDevicePhysicalHeight();
1450 deviceWidth = SystemProperties::GetDevicePhysicalWidth();
1451 maxDeviceLength = std::max(deviceHeight, deviceWidth);
1452 minDeviceLength = std::min(deviceHeight, deviceWidth);
1453 gestureEventHub->GetPixelMapScale(height, width);
1454 EXPECT_TRUE(maxDeviceLength * PIXELMAP_DEFALUT_LIMIT_SCALE > minDeviceLength);
1455 EXPECT_FALSE(height > minDeviceLength * PIXELMAP_DEFALUT_LIMIT_SCALE);
1456 }
1457
1458 /**
1459 * @tc.name: GestureEventHubGetPixelMapScaleTest003
1460 * @tc.desc: Test GetPixelMapScale
1461 * @tc.type: FUNC
1462 */
1463 HWTEST_F(GestureEventHubTestNg, GestureEventHubGetPixelMapScaleTest003, TestSize.Level1)
1464 {
1465 /**
1466 * @tc.steps: step1. Create gestureEventHub.
1467 * @tc.expected: gestureEventHub is not null.
1468 */
1469 auto frameNode1 = FrameNode::CreateFrameNode(V2::WEB_ETS_TAG, 102, AceType::MakeRefPtr<Pattern>());
1470 auto gestureEventHub = frameNode1->GetOrCreateGestureEventHub();
1471 ASSERT_NE(gestureEventHub, nullptr);
1472 auto eventHub = gestureEventHub->eventHub_.Upgrade();
1473 eventHub->AttachHost(frameNode1);
1474 ASSERT_NE(eventHub, nullptr);
1475
1476 /**
1477 * @tc.steps2: Invoke GetPixelMapScale
1478 */
1479 int32_t height = 500;
1480 int32_t width = 600;
1481 constexpr float PIXELMAP_DEFALUT_LIMIT_SCALE = 0.5f;
1482 constexpr float PIXELMAP_DRAG_WGR_SCALE = 3.0f;
1483 SystemProperties::SetDevicePhysicalHeight(600);
1484 SystemProperties::SetDevicePhysicalWidth(600);
1485 int32_t deviceHeight = SystemProperties::GetDevicePhysicalHeight();
1486 int32_t deviceWidth = SystemProperties::GetDevicePhysicalWidth();
1487 int32_t maxDeviceLength = std::max(deviceHeight, deviceWidth);
1488 int32_t minDeviceLength = std::min(deviceHeight, deviceWidth);
1489 gestureEventHub->GetPixelMapScale(height, width);
1490 EXPECT_FALSE(maxDeviceLength * PIXELMAP_DEFALUT_LIMIT_SCALE > minDeviceLength);
1491 EXPECT_FALSE(gestureEventHub->GetTextDraggable());
1492 EXPECT_TRUE(height > minDeviceLength / PIXELMAP_DRAG_WGR_SCALE);
1493 EXPECT_TRUE(width > minDeviceLength * PIXELMAP_DRAG_WGR_TEXT_SCALE / PIXELMAP_DRAG_WGR_SCALE);
1494 EXPECT_TRUE(height > minDeviceLength / PIXELMAP_DRAG_WGR_SCALE);
1495 EXPECT_TRUE(width > minDeviceLength / PIXELMAP_DRAG_WGR_SCALE);
1496
1497 /**
1498 * @tc.steps3: Invoke GetPixelMapScale
1499 */
1500 gestureEventHub->SetTextDraggable(true);
1501 gestureEventHub->GetPixelMapScale(height, width);
1502 EXPECT_FALSE(maxDeviceLength * PIXELMAP_DEFALUT_LIMIT_SCALE > minDeviceLength);
1503 EXPECT_TRUE(gestureEventHub->GetTextDraggable());
1504 EXPECT_TRUE(height > minDeviceLength / PIXELMAP_DRAG_WGR_SCALE);
1505 EXPECT_TRUE(width > minDeviceLength * PIXELMAP_DRAG_WGR_TEXT_SCALE / PIXELMAP_DRAG_WGR_SCALE);
1506
1507 /**
1508 * @tc.steps4: Invoke GetPixelMapScale
1509 */
1510 height = 100;
1511 width = 100;
1512 gestureEventHub->SetTextDraggable(false);
1513 gestureEventHub->GetPixelMapScale(height, width);
1514 EXPECT_FALSE(maxDeviceLength * PIXELMAP_DEFALUT_LIMIT_SCALE > minDeviceLength);
1515 EXPECT_FALSE(gestureEventHub->GetTextDraggable());
1516 EXPECT_FALSE(height > minDeviceLength / PIXELMAP_DRAG_WGR_SCALE);
1517 EXPECT_FALSE(width > minDeviceLength / PIXELMAP_DRAG_WGR_SCALE);
1518 }
1519
1520 /**
1521 * @tc.name: ProcessTouchTestHit001
1522 * @tc.desc: Test ProcessTouchTestHit func
1523 * @tc.type: FUNC
1524 */
1525 HWTEST_F(GestureEventHubTestNg, ProcessTouchTestHit001, TestSize.Level1)
1526 {
1527 /**
1528 * @tc.steps: step1. Create GestureEventHub.
1529 * @tc.expected: gestureEventHub is not null.
1530 */
1531 auto gridNode = CreateGridNodeWithChild(DEFAULT_CHILD_COUNT, GridItemStyle::NONE);
1532 ASSERT_NE(gridNode, nullptr);
1533 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
1534 ASSERT_NE(gestureEventHub, nullptr);
1535 auto recognizerGroup = CreateRecognizerGroup(gridNode);
1536 ASSERT_NE(recognizerGroup, nullptr);
1537
1538 /**
1539 * @tc.steps: step2. Invoke ProcessTouchTestHit.
1540 */
1541 gestureEventHub->parallelCombineClick = true;
__anon063235ab1202(GestureEvent& info) 1542 gestureEventHub->SetUserOnClick([](GestureEvent& info) {});
1543
1544 auto userClickEventActuator = gestureEventHub->GetUserClickEventActuator();
1545 ASSERT_NE(userClickEventActuator, nullptr);
1546 TouchRestrict touchRestrict;
1547 TouchTestResult innerTargets;
1548 TouchTestResult finalResult;
1549 ResponseLinkResult responseLinkResult;
1550 innerTargets.emplace_back(recognizerGroup);
1551 gestureEventHub->redirectClick_=true;
1552 auto flag = gestureEventHub->ProcessTouchTestHit(
1553 COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, PointF(), nullptr, responseLinkResult);
1554 EXPECT_FALSE(flag);
1555 }
1556
1557 /**
1558 * @tc.name: StartLongPressActionForWeb001
1559 * @tc.desc: Test StartLongPressActionForWeb func
1560 * @tc.type: FUNC
1561 */
1562 HWTEST_F(GestureEventHubTestNg, StartLongPressActionForWeb001, TestSize.Level1)
1563 {
1564 /**
1565 * @tc.steps: step1. Create GestureEventHub.
1566 * @tc.expected: gestureEventHub is not null.
1567 */
1568 auto gridNode = CreateGridNodeWithChild(DEFAULT_CHILD_COUNT, GridItemStyle::NONE);
1569 ASSERT_NE(gridNode, nullptr);
1570 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
1571 ASSERT_NE(gestureEventHub, nullptr);
1572
1573 /**
1574 * @tc.steps: step2. set DragEvent and handle drag.
1575 */
__anon063235ab1302(GestureEvent& info) 1576 auto dragActionStart = [](GestureEvent& info) {};
__anon063235ab1402(GestureEvent& info) 1577 auto dragActionUpdate = [](GestureEvent& info) {};
__anon063235ab1502(GestureEvent& info) 1578 auto dragActionEnd = [](GestureEvent& info) {};
__anon063235ab1602() 1579 auto dragActionCancel = []() {};
1580 auto dragEvent = AceType::MakeRefPtr<DragEvent>(
1581 std::move(dragActionStart), std::move(dragActionUpdate), std::move(dragActionEnd), std::move(dragActionCancel));
1582 gestureEventHub->SetCustomDragEvent(dragEvent, PAN_DIRECTION_ALL, FINGERS, DISTANCE);
1583
1584 /**
1585 * @tc.steps: step3. create taskExecutor to fire task callBack.
1586 * @tc.expected: taskExecutor is not null.
1587 */
1588 auto context = PipelineContext::GetCurrentContext();
1589 ASSERT_NE(context, nullptr);
1590 context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
1591 auto taskExecutor = context->GetTaskExecutor();
1592 ASSERT_NE(taskExecutor, nullptr);
1593 gestureEventHub->StartLongPressActionForWeb();
1594 EXPECT_NE(gestureEventHub->GetDragEventActuator(), nullptr);
1595 }
1596
1597 /**
1598 * @tc.name: WebDragAction001
1599 * @tc.desc: Test web drag action.
1600 * @tc.type: FUNC
1601 */
1602 HWTEST_F(GestureEventHubTestNg, WebDragAction001, TestSize.Level1)
1603 {
1604 /**
1605 * @tc.steps: step1. Create GestureEventHub.
1606 * @tc.expected: gestureEventHub is not null.
1607 */
1608 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::WEB_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon063235ab1702() 1609 []() {return AceType::MakeRefPtr<Pattern>(); });
1610 ASSERT_NE(frameNode, nullptr);
1611 auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
1612 ASSERT_NE(gestureEventHub, nullptr);
1613
1614 /**
1615 * @tc.steps: step2. set DragEvent and handle drag.
1616 */
__anon063235ab1802(GestureEvent& info) 1617 auto dragActionStart = [](GestureEvent& info) {};
__anon063235ab1902(GestureEvent& info) 1618 auto dragActionUpdate = [](GestureEvent& info) {};
__anon063235ab1a02(GestureEvent& info) 1619 auto dragActionEnd = [](GestureEvent& info) {};
__anon063235ab1b02() 1620 auto dragActionCancel = []() {};
1621 auto dragEvent = AceType::MakeRefPtr<DragEvent>(
1622 std::move(dragActionStart), std::move(dragActionUpdate), std::move(dragActionEnd), std::move(dragActionCancel));
1623 gestureEventHub->SetCustomDragEvent(dragEvent, PAN_DIRECTION_ALL, FINGERS, DISTANCE);
1624 gestureEventHub->HandleNotAllowDrag(GestureEvent());
1625
1626 /**
1627 * @tc.steps: step3. create taskExecutor to fire task callBack.
1628 * @tc.expected: taskExecutor is not null.
1629 */
1630 auto context = PipelineContext::GetCurrentContext();
1631 ASSERT_NE(context, nullptr);
1632 context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
1633 auto taskExecutor = context->GetTaskExecutor();
1634 ASSERT_NE(taskExecutor, nullptr);
1635 gestureEventHub->StartDragTaskForWeb();
1636 gestureEventHub->CancelDragForWeb();
1637 gestureEventHub->ResetDragActionForWeb();
1638 EXPECT_NE(gestureEventHub->GetDragEventActuator(), nullptr);
1639 }
1640
1641 /**
1642 * @tc.name: GenerateMousePixelMap001
1643 * @tc.desc: Test GenerateMousePixelMap func.
1644 * @tc.type: FUNC
1645 */
1646 HWTEST_F(GestureEventHubTestNg, GenerateMousePixelMap001, TestSize.Level1)
1647 {
1648 /**
1649 * @tc.steps: step1. Create text frameNode and add drag frameNode then Create GestureEventHub.
1650 * @tc.expected: gestureEventHub is not null.
1651 */
1652 auto textPattern = AceType::MakeRefPtr<TextPattern>();
1653 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG,
1654 ElementRegister::GetInstance()->MakeUniqueId(), textPattern);
1655 ASSERT_NE(frameNode, nullptr);
1656 auto dragNode = FrameNode::GetOrCreateFrameNode(V2::IMAGE_ETS_TAG,
__anon063235ab1c02() 1657 ElementRegister::GetInstance()->MakeUniqueId(), []() {return AceType::MakeRefPtr<Pattern>(); });
1658 textPattern->dragNode_ = dragNode;
1659 auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
1660 ASSERT_NE(gestureEventHub, nullptr);
1661
1662 /**
1663 * @tc.steps: step2. Invoke GenerateMousePixelMap.
1664 * @tc.expected: TextDraggable is true.
1665 */
1666 gestureEventHub->SetTextDraggable(true);
1667 GestureEvent info;
1668 gestureEventHub->GenerateMousePixelMap(info);
1669 EXPECT_TRUE(gestureEventHub->pixelMap_ == nullptr);
1670 }
1671
1672 /**
1673 * @tc.name: RegisterCoordinationListener001
1674 * @tc.desc: Test RegisterCoordinationListener func.
1675 * @tc.type: FUNC
1676 */
1677 HWTEST_F(GestureEventHubTestNg, RegisterCoordinationListener001, TestSize.Level1)
1678 {
1679 /**
1680 * @tc.steps: step1. Create GestureEventHub.
1681 * @tc.expected: gestureEventHub is not null.
1682 */
1683 auto gridNode = CreateGridNodeWithChild(DEFAULT_CHILD_COUNT, GridItemStyle::NONE);
1684 ASSERT_NE(gridNode, nullptr);
1685 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
1686 ASSERT_NE(gestureEventHub, nullptr);
1687
1688 /**
1689 * @tc.steps: step2. set DragEvent and handle drag.
1690 */
__anon063235ab1d02(GestureEvent& info) 1691 auto dragActionStart = [](GestureEvent& info) {};
__anon063235ab1e02(GestureEvent& info) 1692 auto dragActionUpdate = [](GestureEvent& info) {};
__anon063235ab1f02(GestureEvent& info) 1693 auto dragActionEnd = [](GestureEvent& info) {};
__anon063235ab2002() 1694 auto dragActionCancel = []() {};
1695 auto dragEvent = AceType::MakeRefPtr<DragEvent>(
1696 std::move(dragActionStart), std::move(dragActionUpdate), std::move(dragActionEnd), std::move(dragActionCancel));
1697 gestureEventHub->SetCustomDragEvent(dragEvent, PAN_DIRECTION_ALL, FINGERS, DISTANCE);
1698
1699 /**
1700 * @tc.steps: step3. create taskExecutor to fire task callBack and invoke registerCoordinationListener.
1701 * @tc.expected: registerCoordinationListener is called once.
1702 */
1703 auto context = PipelineContext::GetCurrentContext();
1704 ASSERT_NE(context, nullptr);
1705 context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
1706 auto taskExecutor = context->GetTaskExecutor();
1707 ASSERT_NE(taskExecutor, nullptr);
1708 auto mock = AceType::DynamicCast<MockInteractionInterface>(InteractionInterface::GetInstance());
1709 ASSERT_NE(mock, nullptr);
1710 gestureEventHub->RegisterCoordinationListener(context);
1711 if (mock->gDragOutCallback) {
1712 mock->gDragOutCallback();
1713 }
1714 }
1715
1716 /**
1717 * @tc.name: GridNodeHandleOnDragUpdate001
1718 * @tc.desc: Test gridnode Drag scene.
1719 * @tc.type: FUNC
1720 */
1721 HWTEST_F(GestureEventHubTestNg, GridNodeHandleOnDragUpdate001, TestSize.Level1)
1722 {
1723 /**
1724 * @tc.steps: step1. Create grid with gridItem frame node tree.
1725 * @tc.expected: instance is not null.
1726 */
1727 auto gridNode = CreateGridNodeWithChild(DEFAULT_CHILD_COUNT, GridItemStyle::NONE);
1728 ASSERT_NE(gridNode, nullptr);
1729 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
1730 ASSERT_NE(gestureEventHub, nullptr);
1731 for (const auto& child : gridNode->GetChildren()) {
1732 auto childNode = AceType::DynamicCast<FrameNode>(child);
1733 ASSERT_TRUE(childNode != nullptr);
1734 auto gridItemPattern = childNode->GetPattern<GridItemPattern>();
1735 ASSERT_TRUE(gridItemPattern != nullptr);
1736 gridItemPattern->SetSelected(true);
1737 }
1738 auto gridItem = AceType::DynamicCast<FrameNode>(gridNode->GetChildByIndex(0));
1739 ASSERT_NE(gridItem, nullptr);
1740 auto pattern = gridNode->GetPattern<GridPattern>();
1741 ASSERT_NE(pattern, nullptr);
1742 pattern->info_.endIndex_ = DEFAULT_CHILD_COUNT;
1743
1744 /**
1745 * @tc.steps: step2. set all griditems are selected.
1746 */
1747 gestureEventHub->InitDragDropEvent();
1748 constexpr int64_t PROXY_ID_NOT_FIT = 101;
1749 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
1750 gestureEventHub->dragDropProxy_ = dragDropProxy;
1751 auto actuator = gestureEventHub->GetDragEventActuator();
1752 ASSERT_NE(actuator, nullptr);
1753 actuator->isSelectedItemNode_ = true;
1754 actuator->FindItemParentNode(gridItem);
1755
1756 /**
1757 * @tc.steps: step3. handle grid drag when switch to subwindow.
1758 */
1759 GestureEvent info;
1760 gestureEventHub->HandleOnDragStart(info);
1761 for (double step = 0; step < DEFAULT_OFFSET_Y; ++step) {
1762 info.SetOffsetY(step);
1763 gestureEventHub->HandleOnDragUpdate(info);
1764 }
1765 gestureEventHub->HandleOnDragEnd(info);
1766 EXPECT_NE(gestureEventHub->gestureInfoForWeb_, nullptr);
1767 }
1768
1769 /**
1770 * @tc.name: GetDragCallback001
1771 * @tc.desc: Test GetDragCallback fun and fire callback.
1772 * @tc.type: FUNC
1773 */
1774 HWTEST_F(GestureEventHubTestNg, GetDragCallback001, TestSize.Level1)
1775 {
1776 /**
1777 * @tc.steps: step1. Create grid with gridItem frame node tree.
1778 * @tc.expected: instance is not null.
1779 */
1780 auto gridNode = CreateGridNodeWithChild(DEFAULT_CHILD_COUNT, GridItemStyle::NONE);
1781 ASSERT_NE(gridNode, nullptr);
1782 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
1783 ASSERT_NE(gestureEventHub, nullptr);
1784 auto eventHub = gridNode->GetOrCreateEventHub<GridEventHub>();
1785
1786 /**
1787 * @tc.steps: step2. create taskExecutor to fire task callBack.
1788 * @tc.expected: taskExecutor is not null.
1789 */
1790 auto context = PipelineContext::GetCurrentContext();
1791 ASSERT_NE(context, nullptr);
1792 context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
1793 auto taskExecutor = context->GetTaskExecutor();
1794 ASSERT_NE(taskExecutor, nullptr);
1795 auto dragDropManager = context->GetDragDropManager();
1796 ASSERT_NE(dragDropManager, nullptr);
1797 auto mock = AceType::DynamicCast<MockInteractionInterface>(InteractionInterface::GetInstance());
1798 ASSERT_NE(mock, nullptr);
1799
1800 /**
1801 * @tc.steps: step3. Invoke GetDragCallback to get function and fire this function.
1802 * @tc.expected: fire function success.
1803 */
1804 MockContainer::SetUp();
1805 int32_t callbackInfo = 0;
__anon063235ab2102(const RefPtr<OHOS::Ace::DragEvent>& ) 1806 eventHub->SetOnDragEnd([&callbackInfo](const RefPtr<OHOS::Ace::DragEvent>& /*dragEvent*/) {
1807 callbackInfo = 1;
1808 });
1809 auto dragCallback = gestureEventHub->GetDragCallback(context, eventHub);
1810 ASSERT_NE(dragCallback, nullptr);
1811 EXPECT_CALL(*mock, UnRegisterCoordinationListener()).Times(1).WillOnce(Return(50));
1812 DragNotifyMsgCore notifyMessage;
1813 dragCallback(notifyMessage);
1814 EXPECT_FALSE(dragDropManager->IsDragged());
1815 EXPECT_EQ(callbackInfo, 1);
1816 MockContainer::TearDown();
1817 }
1818
1819 /**
1820 * @tc.name: CopyGestures001
1821 * @tc.desc: Test CopyGestures from another guestureEventHub.
1822 * @tc.type: FUNC
1823 */
1824 HWTEST_F(GestureEventHubTestNg, CopyGestures001, TestSize.Level1)
1825 {
1826 /**
1827 * @tc.steps: step1. Create guestureEventHub dest and source.
1828 */
1829 auto eventHubSrc = AceType::MakeRefPtr<EventHub>();
1830 auto eventHubDest = AceType::MakeRefPtr<EventHub>();
1831 auto gestureEventHubSrc = eventHubSrc->GetOrCreateGestureEventHub();
1832 auto gestureEventHubDest = eventHubDest->GetOrCreateGestureEventHub();
1833 auto longPressGesture = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
1834 longPressGesture->SetTag(CHECK_TAG_1);
1835 gestureEventHubSrc->AddGesture(longPressGesture);
1836
1837 /**
1838 * @tc.steps: step2. Invoke CopyGestures.
1839 * @tc.expected: The member variable of dest is a copy of source.
1840 */
1841 gestureEventHubDest->CopyGestures(gestureEventHubSrc);
1842 EXPECT_EQ(gestureEventHubDest->gestures_.size(), gestureEventHubSrc->gestures_.size());
1843 EXPECT_TRUE(gestureEventHubDest->recreateGesture_);
1844 }
1845
1846 /**
1847 * @tc.name: SetResponseRegionWithRemove001
1848 * @tc.desc: Test SetResponseRegion with RemoveLastResponseRect.
1849 * @tc.type: FUNC
1850 */
1851 HWTEST_F(GestureEventHubTestNg, SetResponseRegionWithRemove001, TestSize.Level1)
1852 {
1853 /**
1854 * @tc.steps: step1. Create guestureEventHub.
1855 */
1856 auto eventHub = AceType::MakeRefPtr<EventHub>();
1857 auto gestureEventHub = eventHub->GetOrCreateGestureEventHub();
1858
1859 /**
1860 * @tc.steps: step2. Invoke SetResponseRegion.
1861 * @tc.expected: SetResponseRegion success.
1862 */
1863 std::vector<DimensionRect> responseRegion;
1864 responseRegion.push_back(DimensionRect());
1865 int32_t callbackInfo = 0;
__anon063235ab2202(const std::vector<DimensionRect>& ) 1866 gestureEventHub->SetResponseRegionFunc([&callbackInfo](const std::vector<DimensionRect>& /*reponseRegion*/) {
1867 callbackInfo = 1;
1868 });
1869 gestureEventHub->SetResponseRegion(responseRegion);
1870 EXPECT_EQ(gestureEventHub->responseRegion_.size(), responseRegion.size());
1871
1872 /**
1873 * @tc.steps: step3. Invoke RemoveLastResponseRect.
1874 * @tc.expected: RemoveLastResponseRect success and fire responseRegionFunc.
1875 */
1876 gestureEventHub->RemoveLastResponseRect();
1877 EXPECT_TRUE(gestureEventHub->responseRegion_.empty());
1878 EXPECT_EQ(callbackInfo, 1);
1879 }
1880
1881 /**
1882 * @tc.name: SetDragGatherPixelMaps001
1883 * @tc.desc: Test SetDragGatherPixelMaps when input type is mouse button.
1884 * @tc.type: FUNC
1885 */
1886 HWTEST_F(GestureEventHubTestNg, SetDragGatherPixelMaps001, TestSize.Level1)
1887 {
1888 /**
1889 * @tc.steps: step1. Create grid with gridItem frame node tree.
1890 * @tc.expected: instance is not null.
1891 */
1892 auto gridNode = ProcessDragItemGroupScene();
1893 ASSERT_NE(gridNode, nullptr);
1894 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
1895 ASSERT_NE(gestureEventHub, nullptr);
1896 auto context = PipelineContext::GetCurrentContext();
1897 ASSERT_NE(context, nullptr);
1898 auto dragDropManager = context->GetDragDropManager();
1899 ASSERT_NE(dragDropManager, nullptr);
1900
1901 /**
1902 * @tc.steps: step2. Invoke SetDragGatherPixelMaps.
1903 * @tc.expected: gatherPixelMaps is not empty.
1904 */
1905 GestureEvent info;
1906 info.SetInputEventType(InputEventType::MOUSE_BUTTON);
1907 gestureEventHub->SetDragGatherPixelMaps(info);
1908 EXPECT_TRUE(dragDropManager->gatherPixelMaps_.empty());
1909 }
1910
1911 /**
1912 * @tc.name: SetDragGatherPixelMaps002
1913 * @tc.desc: Test SetDragGatherPixelMaps when input type is not mouse button.
1914 * @tc.type: FUNC
1915 */
1916 HWTEST_F(GestureEventHubTestNg, SetDragGatherPixelMaps002, TestSize.Level1)
1917 {
1918 /**
1919 * @tc.steps: step1. Create grid with gridItem frame node tree.
1920 * @tc.expected: instance is not null.
1921 */
1922 auto gridNode = ProcessDragItemGroupScene();
1923 ASSERT_NE(gridNode, nullptr);
1924 auto gestureEventHub = gridNode->GetOrCreateGestureEventHub();
1925 ASSERT_NE(gestureEventHub, nullptr);
1926
1927 /**
1928 * @tc.steps: step2. Init prefabricated values.
1929 */
1930 auto context = PipelineContext::GetCurrentContext();
1931 ASSERT_NE(context, nullptr);
1932 auto dragDropManager = context->GetDragDropManager();
1933 ASSERT_NE(dragDropManager, nullptr);
1934 auto overlayManager = context->GetOverlayManager();
1935 ASSERT_NE(overlayManager, nullptr);
1936 auto imageNode = FrameNode::CreateFrameNode(V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
1937 AceType::MakeRefPtr<ImagePattern>());
1938 ASSERT_NE(imageNode, nullptr);
1939 GatherNodeChildInfo gatherNodeChildInfo;
1940 gatherNodeChildInfo.imageNode = imageNode;
1941 std::vector<GatherNodeChildInfo> gatherNodeChildInfos;
1942 gatherNodeChildInfos.emplace_back(gatherNodeChildInfo);
1943 ASSERT_NE(gestureEventHub->GetFrameNode(), nullptr);
1944 overlayManager->MountGatherNodeToRootNode(gestureEventHub->GetFrameNode(), gatherNodeChildInfos);
1945
1946 /**
1947 * @tc.steps: step3. Invoke SetDragGatherPixelMaps.
1948 * @tc.expected: gatherPixelMaps is not empty.
1949 */
1950 GestureEvent info;
1951 info.SetInputEventType(InputEventType::TOUCH_SCREEN);
1952 gestureEventHub->SetDragGatherPixelMaps(info);
1953 EXPECT_TRUE(dragDropManager->gatherPixelMaps_.empty());
1954 }
1955
1956 /**
1957 * @tc.name: GetSelectItemSize001
1958 * @tc.desc: Test GetSelectItemSize.
1959 * @tc.type: FUNC
1960 */
1961 HWTEST_F(GestureEventHubTestNg, GetSelectItemSize001, TestSize.Level1)
1962 {
1963 /**
1964 * @tc.steps: step1. Create grid with gridItem frame node tree.
1965 * @tc.expected: instance is not null.
1966 */
1967 SystemProperties::dragDropFrameworkStatus_ = 3;
1968 auto gridNode = ProcessDragItemGroupScene();
1969 ASSERT_NE(gridNode, nullptr);
1970 auto gridItem = AceType::DynamicCast<FrameNode>(gridNode->GetChildByIndex(0));
1971 ASSERT_NE(gridItem, nullptr);
1972 auto gestureEventHub = gridItem->GetOrCreateGestureEventHub();
1973 ASSERT_NE(gestureEventHub, nullptr);
1974
1975 /**
1976 * @tc.steps: step2. Invoke GetSelectItemSize.
1977 * @tc.expected: size is equal to children count.
1978 */
1979 EXPECT_EQ(gestureEventHub->GetSelectItemSize(), gridNode->GetChildren().size());
1980 }
1981
1982 /**
1983 * @tc.name: RemoveGesturesByTag001
1984 * @tc.desc: Test RemoveGesturesByTag.
1985 * @tc.type: FUNC
1986 */
1987 HWTEST_F(GestureEventHubTestNg, RemoveGesturesByTag001, TestSize.Level1)
1988 {
1989 /**
1990 * @tc.steps: step1. Create gestureEventHub and create gesture list.
1991 * @tc.expected: instance is not null.
1992 */
1993 auto eventHub = AceType::MakeRefPtr<EventHub>();
1994 auto gestureEventHub = eventHub->GetOrCreateGestureEventHub();
1995 ASSERT_NE(gestureEventHub, nullptr);
1996 std::vector<RefPtr<Gesture>> gestures;
1997 auto longPressGestureOne = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
1998 longPressGestureOne->SetTag(CHECK_TAG_1);
1999 gestureEventHub->AttachGesture(longPressGestureOne);
2000 auto longPressGestureTwo = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
2001 gestures.emplace_back(longPressGestureTwo);
2002 auto longPressGestureThree = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
2003 gestures.emplace_back(longPressGestureThree);
2004 auto group = AceType::MakeRefPtr<GestureGroup>(GestureMode::Exclusive, gestures);
2005 gestureEventHub->AttachGesture(group);
2006
2007 /**
2008 * @tc.steps: step2. Invoke RemoveGesturesByTag.
2009 * @tc.expected: Remove Gestures by tag. modifierGestures_ size is 1 (only GestureGroup).
2010 */
2011 gestureEventHub->RemoveGesturesByTag(CHECK_TAG_1);
2012 EXPECT_EQ(gestureEventHub->modifierGestures_.size(), 1);
2013 }
2014
2015 /**
2016 * @tc.name: FireCustomerOnDragEnd001
2017 * @tc.desc: Test FireCustomerOnDragEnd.
2018 * @tc.type: FUNC
2019 */
2020 HWTEST_F(GestureEventHubTestNg, FireCustomerOnDragEnd001, TestSize.Level1)
2021 {
2022 /**
2023 * @tc.steps: step1. Create gestureEventHub.
2024 * @tc.expected: instance is not null.
2025 */
2026 auto eventHub = AceType::MakeRefPtr<EventHub>();
2027 auto gestureEventHub = eventHub->GetOrCreateGestureEventHub();
2028 ASSERT_NE(gestureEventHub, nullptr);
2029
2030 /**
2031 * @tc.steps: step2. Invoke FireCustomerOnDragEnd.
2032 * @tc.expected: eventHub fire dragEnd callback.
2033 */
2034 int callbackInfo = 0;
__anon063235ab2302(const RefPtr<OHOS::Ace::DragEvent>& ) 2035 eventHub->SetOnDragEnd([&callbackInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */) {
2036 callbackInfo = 1;
2037 });
2038 auto context = PipelineContext::GetCurrentContext();
2039 gestureEventHub->FireCustomerOnDragEnd(context, eventHub);
2040 EXPECT_EQ(callbackInfo, 1);
2041 }
2042 } // namespace OHOS::Ace::NG