1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "test/unittest/core/event/gesture_event_hub_test_ng.h"
17
18 #include "test/mock/core/common/mock_container.h"
19 #include "test/mock/core/common/mock_interaction_interface.h"
20 #include "test/unittest/core/pattern/scrollable/mock_scrollable.h"
21
22 #include "frameworks/core/components_ng/pattern/text/text_pattern.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS::Ace::NG {
SetUpTestSuite()28 void GestureEventHubTestCoverageNg::SetUpTestSuite()
29 {
30 MockContainer::SetUp();
31 MockPipelineContext::SetUp();
32 MOCK_DRAG_WINDOW = DragWindow::CreateDragWindow("", 0, 0, 0, 0);
33 MOCK_TASK_EXECUTOR = AceType::MakeRefPtr<MockTaskExecutor>();
34 }
35
TearDownTestSuite()36 void GestureEventHubTestCoverageNg::TearDownTestSuite()
37 {
38 MockContainer::TearDown();
39 MockPipelineContext::TearDown();
40 MOCK_DRAG_WINDOW = nullptr;
41 }
42
43 /**
44 * @tc.name: GestureEventHubTestCoverage001
45 * @tc.desc: test GetPreScaledPixelMapIfExist
46 * @tc.type: FUNC
47 */
48 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage001, TestSize.Level1)
49 {
50 auto eventHub = AceType::MakeRefPtr<EventHub>();
51 EXPECT_TRUE(eventHub);
52 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
53 eventHub->AttachHost(frameNode);
54 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
55 EXPECT_TRUE(gestureEventHub);
56 bool result = true;
57 void* voidPtr = static_cast<void*>(new char[0]);
58 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
59 gestureEventHub->InitDragDropEvent();
60 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
61 gestureEventHub->GetPreScaledPixelMapIfExist(1.0f, pixelMap);
62 gestureEventHub->GetPreScaledPixelMapIfExist(0.0f, pixelMap);
63 gestureEventHub->dragEventActuator_->preScaledPixelMap_ = pixelMap;
64 gestureEventHub->GetPreScaledPixelMapIfExist(1.0f, pixelMap);
65 gestureEventHub->GetPreScaledPixelMapIfExist(0.0f, pixelMap);
66 EXPECT_TRUE(result);
67 }
68
69 /**
70 * @tc.name: GestureEventHubTestCoverage002
71 * @tc.desc: test HandleOnDragStart
72 * @tc.type: FUNC
73 */
74 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage002, TestSize.Level1)
75 {
76 bool result = true;
77 auto eventHub = AceType::MakeRefPtr<EventHub>();
78 ASSERT_NE(eventHub, nullptr);
79 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
80 ASSERT_NE(frameNode, nullptr);
81 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
82 DragDropInfo dragDropInfo;
83 dragDropInfo.customNode = customNode;
84 dragDropInfo.inspectorId = "123";
85 frameNode->SetDragPreview(dragDropInfo);
86
87 eventHub->AttachHost(frameNode);
88 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
89 ASSERT_NE(gestureEventHub, nullptr);
90 gestureEventHub->InitDragDropEvent();
91 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
__anon18345f5b0102(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 92 auto onDragStart = [&customNode](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) {
93 DragDropInfo dragDropInfo;
94 dragDropInfo.customNode = customNode;
95 return dragDropInfo;
96 };
97 eventHub->SetOnDragStart(std::move(onDragStart));
98 auto eventHubTwo = gestureEventHub->eventHub_.Upgrade();
99 ASSERT_NE(eventHubTwo, nullptr);
100 eventHubTwo->SetOnDragStart(std::move(onDragStart));
101 auto eventManager = AceType::MakeRefPtr<EventManager>();
102 ASSERT_NE(eventManager, nullptr);
103 auto pipeline = PipelineContext::GetCurrentContext();
104 pipeline->SetEventManager(eventManager);
105 eventManager->SetLastMoveBeforeUp(false);
106 GestureEvent gestureEvent;
107 gestureEvent.SetSourceDevice(SourceType::TOUCH);
108 gestureEvent.SetInputEventType(InputEventType::MOUSE_BUTTON);
109 gestureEventHub->HandleOnDragStart(gestureEvent);
110 void* voidPtr = static_cast<void*>(new char[0]);
111 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
112 gestureEventHub->dragEventActuator_->preScaledPixelMap_ = pixelMap;
113 gestureEventHub->dragPreviewPixelMap_ = pixelMap;
114 gestureEventHub->HandleOnDragStart(gestureEvent);
115 EXPECT_TRUE(result);
116 }
117
118 /**
119 * @tc.name: GestureEventHubTestCoverage003
120 * @tc.desc: test HandleOnDragStart
121 * @tc.type: FUNC
122 */
123 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage003, TestSize.Level1)
124 {
125 bool result = true;
126 auto eventHub = AceType::MakeRefPtr<EventHub>();
127 ASSERT_NE(eventHub, nullptr);
128 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
129 ASSERT_NE(frameNode, nullptr);
130 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
131 DragDropInfo dragDropInfo;
132 dragDropInfo.customNode = customNode;
133 frameNode->SetDragPreview(dragDropInfo);
134 eventHub->AttachHost(frameNode);
135 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
136 ASSERT_NE(gestureEventHub, nullptr);
137 gestureEventHub->InitDragDropEvent();
138 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
__anon18345f5b0202(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 139 auto onDragStart = [&customNode](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) {
140 DragDropInfo dragDropInfo;
141 dragDropInfo.customNode = customNode;
142 return dragDropInfo;
143 };
144 eventHub->SetOnDragStart(std::move(onDragStart));
145 auto eventHubTwo = gestureEventHub->eventHub_.Upgrade();
146 ASSERT_NE(eventHubTwo, nullptr);
147 eventHubTwo->SetOnDragStart(std::move(onDragStart));
148 frameNode->eventHub_ = eventHubTwo;
149 eventHubTwo->AttachHost(frameNode);
150 auto eventManager = AceType::MakeRefPtr<EventManager>();
151 ASSERT_NE(eventManager, nullptr);
152 auto pipeline = PipelineContext::GetCurrentContext();
153 pipeline->SetEventManager(eventManager);
154 eventManager->SetLastMoveBeforeUp(false);
155
156 GestureEvent gestureEvent;
157 gestureEvent.SetSourceDevice(SourceType::TOUCH);
158 gestureEvent.SetInputEventType(InputEventType::MOUSE_BUTTON);
159 gestureEventHub->HandleOnDragStart(gestureEvent);
160 void* voidPtr = static_cast<void*>(new char[0]);
161 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
162 dragDropInfo.pixelMap = pixelMap;
163 frameNode->SetDragPreview(dragDropInfo);
164 gestureEventHub->dragEventActuator_->preScaledPixelMap_ = pixelMap;
165 gestureEventHub->HandleOnDragStart(gestureEvent);
166 gestureEventHub->dragPreviewPixelMap_ = pixelMap;
167 gestureEventHub->HandleOnDragStart(gestureEvent);
168 EXPECT_TRUE(result);
169 }
170
171 /**
172 * @tc.name: GestureEventHubTestCoverage004
173 * @tc.desc: test OnDragStart
174 * @tc.type: FUNC
175 */
176 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage004, TestSize.Level1)
177 {
178 auto eventHub = AceType::MakeRefPtr<EventHub>();
179 ASSERT_NE(eventHub, nullptr);
180 auto childNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
181 ASSERT_NE(childNode, nullptr);
182 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
183 ASSERT_NE(frameNode, nullptr);
184 auto patternNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
185 frameNode->AddChild(childNode);
186 DragDropInfo dragDropInfo;
187 eventHub->AttachHost(frameNode);
188 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
189 ASSERT_NE(gestureEventHub, nullptr);
190 gestureEventHub->InitDragDropEvent();
191 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
192 auto pipeline = PipelineContext::GetCurrentContext();
193 GestureEvent gestureEvent;
194 void* voidPtr = static_cast<void*>(new char[0]);
195 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
196 dragDropInfo.pixelMap = pixelMap;
197 frameNode->SetDragPreview(dragDropInfo);
198 gestureEventHub->dragEventActuator_->preScaledPixelMap_ = pixelMap;
199 gestureEventHub->dragPreviewPixelMap_ = pixelMap;
200 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
201 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(101);
202 gestureEventHub->dragDropProxy_ = dragDropProxy;
203 auto textPattern = AceType::MakeRefPtr<TextPattern>();
204 textPattern->dragRecordSize_ = 1;
205 frameNode->pattern_ = textPattern;
206 frameNode->GetOrCreateFocusHub();
207 auto mainPipeline = PipelineContext::GetMainPipelineContext();
208 auto overlayManager = mainPipeline->GetOverlayManager();
209 overlayManager->pixmapColumnNodeWeak_ = WeakPtr<FrameNode>(AceType::DynamicCast<FrameNode>(frameNode));
210 gestureEventHub->OnDragStart(gestureEvent, pipeline, frameNode, dragDropInfo, event);
211 gestureEventHub->dragEventActuator_->itemParentNode_ = patternNode;
212 auto mockPn = AceType::MakeRefPtr<FullyMockedScrollable>();
213 patternNode->pattern_ = mockPn;
214 gestureEventHub->dragEventActuator_->isSelectedItemNode_ = true;
215 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
216 dragDropInfo.pixelMap = pixmap;
217 EXPECT_CALL(*pixmap, GetWidth()).WillRepeatedly(Return(200));
218 gestureEvent.inputEventType_ = InputEventType::MOUSE_BUTTON;
219 auto mock = AceType::DynamicCast<MockInteractionInterface>(InteractionInterface::GetInstance());
220 if (mock->gDragOutCallback) {
221 mock->gDragOutCallback();
222 }
223 gestureEventHub->OnDragStart(gestureEvent, pipeline, frameNode, dragDropInfo, event);
224 EXPECT_EQ(gestureEvent.inputEventType_, InputEventType::MOUSE_BUTTON);
225 }
226
227 /**
228 * @tc.name: GestureEventHubTestCoverage005
229 * @tc.desc: test OnDragStart
230 * @tc.type: FUNC
231 */
232 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage005, TestSize.Level1)
233 {
234 auto eventHub = AceType::MakeRefPtr<EventHub>();
235 ASSERT_NE(eventHub, nullptr);
236 auto childNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
237 ASSERT_NE(childNode, nullptr);
238 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
239 ASSERT_NE(frameNode, nullptr);
240 frameNode->AddChild(childNode);
241 DragDropInfo dragDropInfo;
242 eventHub->AttachHost(frameNode);
243 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
244 ASSERT_NE(gestureEventHub, nullptr);
245 gestureEventHub->InitDragDropEvent();
246 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
247 auto pipeline = PipelineContext::GetCurrentContext();
248 GestureEvent gestureEvent;
249 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
250 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
251 event->SetData(unifiedData);
252 auto textPattern = AceType::MakeRefPtr<TextPattern>();
253 frameNode->pattern_ = textPattern;
254 frameNode->GetOrCreateFocusHub();
255 gestureEventHub->dragEventActuator_->isSelectedItemNode_ = true;
256 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
257 dragDropInfo.pixelMap = pixmap;
258 frameNode->SetDragPreview(dragDropInfo);
259 gestureEventHub->dragEventActuator_->preScaledPixelMap_ = pixmap;
260 EXPECT_CALL(*pixmap, GetWidth()).WillRepeatedly(Return(200));
261 auto mainPipeline = PipelineContext::GetMainPipelineContext();
262 auto overlayManager = mainPipeline->GetOverlayManager();
263 overlayManager->pixmapColumnNodeWeak_ = WeakPtr<FrameNode>(AceType::DynamicCast<FrameNode>(frameNode));
264 gestureEventHub->textDraggable_ = true;
265 gestureEventHub->OnDragStart(gestureEvent, pipeline, frameNode, dragDropInfo, event);
266 textPattern->dragNode_ = childNode;
267 gestureEventHub->OnDragStart(gestureEvent, pipeline, frameNode, dragDropInfo, event);
268 EXPECT_EQ(gestureEventHub->textDraggable_, true);
269 }
270
271 /**
272 * @tc.name: GestureEventHubTestCoverage006
273 * @tc.desc: test OnDragStart
274 * @tc.type: FUNC
275 */
276 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage006, TestSize.Level1)
277 {
278 auto eventHub = AceType::MakeRefPtr<EventHub>();
279 ASSERT_NE(eventHub, nullptr);
280 auto childNode = AceType::MakeRefPtr<FrameNode>(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
281 ASSERT_NE(childNode, nullptr);
282 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
283 ASSERT_NE(frameNode, nullptr);
284 frameNode->AddChild(childNode);
285 DragDropInfo dragDropInfo;
286 eventHub->AttachHost(frameNode);
287 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
288 ASSERT_NE(gestureEventHub, nullptr);
289 gestureEventHub->InitDragDropEvent();
290 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
291 auto pipeline = PipelineContext::GetCurrentContext();
292 GestureEvent gestureEvent;
293 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
294 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
295 event->SetData(unifiedData);
296 auto textPattern = AceType::MakeRefPtr<TextPattern>();
297 frameNode->pattern_ = textPattern;
298 frameNode->GetOrCreateFocusHub();
299 gestureEventHub->dragEventActuator_->isSelectedItemNode_ = true;
300 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
301 dragDropInfo.pixelMap = pixmap;
302 frameNode->SetDragPreview(dragDropInfo);
303 gestureEventHub->dragEventActuator_->preScaledPixelMap_ = pixmap;
304 EXPECT_CALL(*pixmap, GetWidth()).WillRepeatedly(Return(200));
305 auto mainPipeline = PipelineContext::GetMainPipelineContext();
306 auto overlayManager = mainPipeline->GetOverlayManager();
307 overlayManager->pixmapColumnNodeWeak_ = WeakPtr<FrameNode>(AceType::DynamicCast<FrameNode>(frameNode));
308 gestureEventHub->textDraggable_ = true;
309 gestureEventHub->OnDragStart(gestureEvent, pipeline, frameNode, dragDropInfo, event);
310 EXPECT_EQ(gestureEventHub->textDraggable_, true);
311 }
312
313 /**
314 * @tc.name: GestureEventHubTestCoverage007
315 * @tc.desc: test CheckClickActuator
316 * @tc.type: FUNC
317 */
318 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage007, TestSize.Level1)
319 {
320 auto eventHub = AceType::MakeRefPtr<EventHub>();
321 ASSERT_NE(eventHub, nullptr);
322 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
323 ASSERT_NE(gestureEventHub, nullptr);
324 gestureEventHub->parallelCombineClick = true;
__anon18345f5b0302(GestureEvent& info) 325 GestureEventFunc gestureEventFunc = [](GestureEvent& info) {};
326 gestureEventHub->SetJSFrameNodeOnClick(std::move(gestureEventFunc));
327 gestureEventHub->CheckClickActuator();
328 EXPECT_EQ(gestureEventHub->parallelCombineClick, true);
329 }
330
331 /**
332 * @tc.name: GestureEventHubTestCoverage008
333 * @tc.desc: test ClearJSFrameNodeOnClick
334 * @tc.type: FUNC
335 */
336 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage008, TestSize.Level1)
337 {
338 auto eventHub = AceType::MakeRefPtr<EventHub>();
339 ASSERT_NE(eventHub, nullptr);
340 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
341 ASSERT_NE(gestureEventHub, nullptr);
342 gestureEventHub->ClearJSFrameNodeOnClick();
343 EXPECT_EQ(gestureEventHub->touchEventActuator_, nullptr);
344 }
345
346 /**
347 * @tc.name: GestureEventHubTestCoverage009
348 * @tc.desc: test OnDragStart
349 * @tc.type: FUNC
350 */
351 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage009, TestSize.Level1)
352 {
353 auto eventHub = AceType::MakeRefPtr<EventHub>();
354 auto childNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
355 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
356 ASSERT_NE(frameNode, nullptr);
357 auto patternNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
358 frameNode->AddChild(childNode);
359 DragDropInfo dragDropInfo;
360 eventHub->AttachHost(frameNode);
361 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
362 ASSERT_NE(gestureEventHub, nullptr);
363 gestureEventHub->InitDragDropEvent();
364 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
365 auto pipeline = PipelineContext::GetCurrentContext();
366 GestureEvent gestureEvent;
367 void* voidPtr = static_cast<void*>(new char[0]);
368 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
369 dragDropInfo.pixelMap = pixelMap;
370 frameNode->SetDragPreview(dragDropInfo);
371 gestureEventHub->dragEventActuator_->preScaledPixelMap_ = pixelMap;
372 gestureEventHub->dragPreviewPixelMap_ = pixelMap;
373 RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
374 auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(101);
375 gestureEventHub->dragDropProxy_ = dragDropProxy;
376 auto textPattern = AceType::MakeRefPtr<TextPattern>();
377 textPattern->dragRecordSize_ = 1;
378 frameNode->pattern_ = textPattern;
379 frameNode->GetOrCreateFocusHub();
380 auto mainPipeline = PipelineContext::GetMainPipelineContext();
381 auto overlayManager = mainPipeline->GetOverlayManager();
382 overlayManager->pixmapColumnNodeWeak_ = WeakPtr<FrameNode>(AceType::DynamicCast<FrameNode>(frameNode));
383 gestureEventHub->OnDragStart(gestureEvent, pipeline, frameNode, dragDropInfo, event);
384 gestureEventHub->dragEventActuator_->itemParentNode_ = patternNode;
385 auto mockPn = AceType::MakeRefPtr<FullyMockedScrollable>();
386 patternNode->pattern_ = mockPn;
387 gestureEventHub->dragEventActuator_->isSelectedItemNode_ = true;
388 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
389 dragDropInfo.pixelMap = pixmap;
390 EXPECT_CALL(*pixmap, GetWidth()).WillRepeatedly(Return(200));
391 gestureEvent.inputEventType_ = InputEventType::MOUSE_BUTTON;
392 auto mock = AceType::DynamicCast<MockInteractionInterface>(InteractionInterface::GetInstance());
393 if (mock->gDragOutCallback) {
394 mock->gDragOutCallback();
395 }
396 mock->gStartDrag = 1;
397 gestureEventHub->OnDragStart(gestureEvent, pipeline, frameNode, dragDropInfo, event);
398 mock->gStartDrag = 0;
399 EXPECT_EQ(gestureEvent.inputEventType_, InputEventType::MOUSE_BUTTON);
400 }
401
402 /**
403 * @tc.name: GestureEventHubTestCoverage010
404 * @tc.desc: test GetDefaultPixelMapScale
405 * @tc.type: FUNC
406 */
407 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage010, TestSize.Level1)
408 {
409 /**
410 * @tc.steps: step1. create gestureEventHub, gestureEvent and pixelMap.
411 */
412 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
413 auto eventHub = AceType::MakeRefPtr<EventHub>();
414 ASSERT_NE(eventHub, nullptr);
415 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
416 ASSERT_NE(gestureEventHub, nullptr);
417
418 GestureEvent gestureEvent;
419 gestureEvent.SetSourceDevice(SourceType::TOUCH);
420 gestureEvent.SetInputEventType(InputEventType::MOUSE_BUTTON);
421 void* voidPtr = static_cast<void*>(new char[0]);
422 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
423
424 /**
425 * @tc.steps: step2. test default mouse scale.
426 */
427 auto defaultScale = gestureEventHub->GetDefaultPixelMapScale(frameNode, gestureEvent, false, pixelMap);
428 EXPECT_EQ(defaultScale, 1.0f);
429
430 /**
431 * @tc.steps: step3. test default touch scale.
432 */
433 gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
434 defaultScale = gestureEventHub->GetDefaultPixelMapScale(frameNode, gestureEvent, false, pixelMap);
435 EXPECT_EQ(defaultScale, 1.05f);
436
437 /**
438 * @tc.steps: step4. test menu scale.
439 */
440 gestureEventHub->menuPreviewScale_ = 2.0f;
441 defaultScale = gestureEventHub->GetDefaultPixelMapScale(frameNode, gestureEvent, true, pixelMap);
442 EXPECT_EQ(defaultScale, 2.0f);
443 }
444
445 /**
446 * @tc.name: GestureEventHubTestCoverage011
447 * @tc.desc: test GetPreScaledPixelMapIfExist
448 * @tc.type: FUNC
449 */
450 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage011, TestSize.Level1)
451 {
452 DragDropInfo dragDropInfo;
453 dragDropInfo.onlyForLifting = true;
454 auto eventHub = AceType::MakeRefPtr<EventHub>();
455 EXPECT_TRUE(eventHub);
456 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
457 frameNode->SetDragPreview(dragDropInfo);
458 eventHub->AttachHost(frameNode);
459 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
460 EXPECT_TRUE(gestureEventHub);
461 void* voidPtr = static_cast<void*>(new char[0]);
462 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
463 gestureEventHub->InitDragDropEvent();
464 EXPECT_EQ(gestureEventHub->GetPreScaledPixelMapIfExist(0.0f, pixelMap), pixelMap);
465 }
466
467 /**
468 * @tc.name: GestureEventHubTestCoverage012
469 * @tc.desc: test GetDefaultPixelMapScale
470 * @tc.type: FUNC
471 */
472 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage012, TestSize.Level1)
473 {
474 /**
475 * @tc.steps: step1. create gestureEventHub, gestureEvent and pixelMap.
476 */
477 DragDropInfo dragDropInfo;
478 dragDropInfo.onlyForLifting = true;
479 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
480 frameNode->SetDragPreview(dragDropInfo);
481 auto eventHub = AceType::MakeRefPtr<EventHub>();
482 ASSERT_NE(eventHub, nullptr);
483 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
484 ASSERT_NE(gestureEventHub, nullptr);
485
486 GestureEvent gestureEvent;
487 gestureEvent.SetSourceDevice(SourceType::TOUCH);
488 void* voidPtr = static_cast<void*>(new char[0]);
489 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
490
491 /**
492 * @tc.steps: step4. test onlyForLifting.
493 */
494 gestureEventHub->menuPreviewScale_ = 2.0f;
495 auto defaultScale = gestureEventHub->GetDefaultPixelMapScale(frameNode, gestureEvent, true, pixelMap);
496 EXPECT_EQ(defaultScale, 1.05f);
497 }
498
499 /**
500 * @tc.name: GestureEventHubTestCoverage013
501 * @tc.desc: Test GetDragDropInfo function.
502 * @tc.type: FUNC
503 */
504 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage013, TestSize.Level1)
505 {
506 /**
507 * @tc.steps: step1. Create GestureEventHub.
508 * @tc.expected: gestureEventHub is not null.
509 */
510 auto eventHub = AceType::MakeRefPtr<EventHub>();
511 EXPECT_TRUE(eventHub);
512 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
513 EXPECT_TRUE(gestureEventHub);
514 SystemProperties::dragDropFrameworkStatus_ = 3;
515
516 /**
517 * @tc.steps: step2. set onDragStart for eventHub
518 */
__anon18345f5b0402(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 519 auto onDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
520 DragDropInfo dragDropInfo;
521 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
522 dragEvent->SetData(unifiedData);
523 auto customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
524 dragDropInfo.customNode = customNode;
525 dragDropInfo.extraInfo = "user set extraInfo";
526 return dragDropInfo;
527 };
528 eventHub->SetOnDragStart(std::move(onDragStart));
529
530 /**
531 * @tc.steps: step3. set dragPreview for frameNode
532 */
533 auto frameNode = FrameNode::CreateFrameNode(V2::IMAGE_ETS_TAG, -1, AceType::MakeRefPtr<ImagePattern>());
534 ASSERT_NE(frameNode, nullptr);
535 DragDropInfo dragPreviewDropInfo;
536 dragPreviewDropInfo.extraInfo = "drag preview extraInfo";
537 auto customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
538 dragPreviewDropInfo.customNode = customNode;
__anon18345f5b0502() 539 auto buildFunc = [node = customNode]() -> RefPtr<NG::UINode> { return AceType::DynamicCast<NG::UINode>(node); };
540 dragPreviewDropInfo.buildFunc = buildFunc;
541 dragPreviewDropInfo.onlyForLifting = true;
542 dragPreviewDropInfo.delayCreating = false;
543 frameNode->SetDragPreview(dragPreviewDropInfo);
544
545 /**
546 * @tc.steps: step4. call GetDragDropInfo function
547 * case: textDraggable is false, and component is image
548 * @tc.expected: dragPreviewInfo.customNode is not null, extraInfo is 'drag preview extraInfo'.
549 */
550 GestureEvent info;
551 DragDropInfo dragPreviewInfo;
552 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
553 gestureEventHub->InitDragDropEvent();
554 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
555 gestureEventHub->SetTextDraggable(true);
556 info.SetInputEventType(InputEventType::MOUSE_BUTTON);
557 auto dragDropInfo = gestureEventHub->GetDragDropInfo(info, frameNode, dragPreviewInfo, dragEvent);
558 EXPECT_TRUE(dragDropInfo.customNode);
559 EXPECT_EQ(dragDropInfo.extraInfo, "user set extraInfo");
560 EXPECT_FALSE(dragPreviewInfo.customNode);
561 EXPECT_NE(dragPreviewInfo.customNode, buildFunc());
562 }
563
564 /**
565 * @tc.name: GestureEventHubTestCoverage014
566 * @tc.desc: Test GetDragDropInfo function.
567 * @tc.type: FUNC
568 */
569 HWTEST_F(GestureEventHubTestCoverageNg, GestureEventHubTestCoverage014, TestSize.Level1)
570 {
571 /**
572 * @tc.steps: step1. Create GestureEventHub.
573 * @tc.expected: gestureEventHub is not null.
574 */
575 auto eventHub = AceType::MakeRefPtr<EventHub>();
576 EXPECT_TRUE(eventHub);
577 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
578 EXPECT_TRUE(gestureEventHub);
579
580 /**
581 * @tc.steps: step2. set onDragStart for eventHub
582 */
__anon18345f5b0602(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& ) 583 auto onDragStart = [](const RefPtr<OHOS::Ace::DragEvent>& dragEvent, const std::string& /* param */) {
584 DragDropInfo dragDropInfo;
585 auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
586 dragEvent->SetData(unifiedData);
587 auto customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
588 dragDropInfo.customNode = customNode;
589 dragDropInfo.extraInfo = "user set extraInfo";
590 return dragDropInfo;
591 };
592 eventHub->SetOnDragStart(std::move(onDragStart));
593
594 /**
595 * @tc.steps: step3. set dragPreview for frameNode
596 */
597 auto frameNode = FrameNode::CreateFrameNode(V2::IMAGE_ETS_TAG, -1, AceType::MakeRefPtr<ImagePattern>());
598 ASSERT_NE(frameNode, nullptr);
599 DragDropInfo dragPreviewDropInfo;
600 dragPreviewDropInfo.extraInfo = "drag preview extraInfo";
601 auto customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
602 dragPreviewDropInfo.customNode = nullptr;
__anon18345f5b0702() 603 auto buildFunc = [node = customNode]() -> RefPtr<NG::UINode> { return AceType::DynamicCast<NG::UINode>(node); };
604 dragPreviewDropInfo.buildFunc = buildFunc;
605 dragPreviewDropInfo.onlyForLifting = false;
606 dragPreviewDropInfo.delayCreating = true;
607 frameNode->SetDragPreview(dragPreviewDropInfo);
608
609 /**
610 * @tc.steps: step4. call GetDragDropInfo function
611 * case: textDraggable is false, and component is image
612 * @tc.expected: dragPreviewInfo.customNode is not null, extraInfo is 'drag preview extraInfo'.
613 */
614 GestureEvent info;
615 DragDropInfo dragPreviewInfo;
616 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
617 gestureEventHub->InitDragDropEvent();
618 ASSERT_NE(gestureEventHub->dragEventActuator_, nullptr);
619 gestureEventHub->SetTextDraggable(true);
620 info.SetInputEventType(InputEventType::MOUSE_BUTTON);
621 auto dragDropInfo = gestureEventHub->GetDragDropInfo(info, frameNode, dragPreviewInfo, dragEvent);
622 EXPECT_TRUE(dragDropInfo.customNode);
623 EXPECT_EQ(dragDropInfo.extraInfo, "user set extraInfo");
624 EXPECT_TRUE(dragPreviewInfo.customNode);
625 EXPECT_EQ(dragPreviewInfo.customNode, buildFunc());
626 }
627 } // namespace OHOS::Ace::NG