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 #include "test/unittest/core/manager/drag_drop_manager_test_ng.h"
16 #include "test/mock/core/common/mock_udmf.h"
17 #include "test/mock/core/render/mock_render_context.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21 namespace OHOS::Ace::NG {
SetUpTestCase()22 void DragDropManagerTestNgNew::SetUpTestCase()
23 {
24 MockPipelineContext::SetUp();
25 MockContainer::SetUp();
26 }
27
TearDownTestCase()28 void DragDropManagerTestNgNew::TearDownTestCase()
29 {
30 MockPipelineContext::TearDown();
31 MockContainer::TearDown();
32 }
33
34 /**
35 * @tc.name: DragDropManagerTest041
36 * @tc.desc: Test FindHitFrameNodes in frameNode branchs(IsActive is false)
37 * @tc.type: FUNC
38 * @tc.author:
39 */
40 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest041, TestSize.Level1)
41 {
42 /**
43 * @tc.steps: step1. construct a DragDropManager.
44 * @tc.expected: dragDropManager is not null.
45 */
46 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
47 ASSERT_NE(dragDropManager, nullptr);
48
49 /**
50 * @tc.steps: step2. construct a frameNode and update attributes.
51 * @tc.expected: geometryNode is null.
52 */
53 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
54 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
55 frameNode->SetActive(false);
56 frameNode->geometryNode_ = nullptr;
57
58 /**
59 * @tc.steps: step3. update nodesForDragNotify_.
60 * @tc.expected: nodesForDragNotify_ is not empty.
61 */
62 dragDropManager->RegisterDragStatusListener(frameNode->GetId(), AceType::WeakClaim(AceType::RawPtr(frameNode)));
63 EXPECT_FALSE(dragDropManager->nodesForDragNotify_.empty());
64
65 /**
66 * @tc.steps: step4. call FindHitFrameNodes out of geometryNode are false branches.
67 * @tc.expected: frameNodeList is empty.
68 */
69 auto frameNodeList = dragDropManager->FindHitFrameNodes(Point(1.0f, 1.0f));
70 EXPECT_TRUE(frameNodeList.empty());
71 }
72
73 /**
74 * @tc.name: DragDropManagerFindDragFrameNodeByPositionTest001
75 * @tc.desc: Test FindDragFrameNodeByPosition
76 * @tc.type: FUNC
77 * @tc.author:
78 */
79 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFindDragFrameNodeByPositionTest001, TestSize.Level1)
80 {
81 /**
82 * @tc.steps: step1. construct a DragDropManager
83 */
84 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
85
86 /**
87 * @tc.steps: step2. call FindDragFrameNodeByPosition with frameNodes contains nullptr
88 * @tc.expected: step2.
89 */
90 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
91 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
92 frameNodeNull.Reset();
93 auto frameNodeGeoNullId = ElementRegister::GetInstance()->MakeUniqueId();
94 auto frameNodeGeoNull =
95 AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeGeoNullId, AceType::MakeRefPtr<Pattern>());
96 frameNodeGeoNull->SetGeometryNode(nullptr);
97 auto targetFrameNode = dragDropManager->FindDragFrameNodeByPosition(GLOBAL_X, GLOBAL_Y);
98 EXPECT_FALSE(targetFrameNode);
99 }
100
101 /**
102 * @tc.name: DragDropManagerPrintDragFrameNodeTest001
103 * @tc.desc: Test PrintDragFrameNode
104 * @tc.type: FUNC
105 * @tc.author:
106 */
107 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerPrintDragFrameNodeTest001, TestSize.Level1)
108 {
109 /**
110 * @tc.steps: step1. construct a DragDropManager
111 */
112 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
113 OHOS::Ace::DragPointerEvent point;
114
115 /**
116 * @tc.steps: step2. call OnDragStart
117 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
118 */
119 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
120 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
121 auto draggedNode = dragDropManager->draggedFrameNode_;
122 auto preTargetNode = dragDropManager->preTargetFrameNode_;
123 dragDropManager->PrintDragFrameNode(point, frameNode);
124 ASSERT_TRUE(draggedNode);
125 ASSERT_TRUE(preTargetNode);
126 auto draggedNodeTag = draggedNode->GetTag();
127 auto preTargetNodeTag = preTargetNode->GetTag();
128 EXPECT_EQ(draggedNodeTag, NODE_TAG);
129 EXPECT_EQ(preTargetNodeTag, NODE_TAG);
130 }
131
132 /**
133 * @tc.name: DragDropManagerFindTargetInChildNodesTest001
134 * @tc.desc: Test PrintDragFrameNode
135 * @tc.type: FUNC
136 * @tc.author:
137 */
138 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFindTargetInChildNodesTest001, TestSize.Level1)
139 {
140 /**
141 * @tc.steps: step1. construct a DragDropManager
142 */
143 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
144
145 /**
146 * @tc.steps: step2. call OnDragStart
147 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
148 */
149 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
150 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
151 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
152 std::vector<RefPtr<FrameNode>> hitFrameNodes;
153 hitFrameNodes.push_back(frameNode);
154 auto draggedNode = dragDropManager->draggedFrameNode_;
155 auto preTargetNode = dragDropManager->preTargetFrameNode_;
156 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
157 ASSERT_TRUE(draggedNode);
158 ASSERT_TRUE(preTargetNode);
159 }
160
161 /**
162 * @tc.name: DragDropManagerFindTargetInChildNodesTest002
163 * @tc.desc: Test FindTargetInChildNodes
164 * @tc.type: FUNC
165 * @tc.author:
166 */
167 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFindTargetInChildNodesTest002, TestSize.Level1)
168 {
169 /**
170 * @tc.steps: step1. construct a DragDropManager
171 */
172 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
173
174 /**
175 * @tc.steps: step2. call OnDragStart
176 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
177 */
178 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
179 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
180 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
181 customNode->SetActive(false);
182 std::vector<RefPtr<FrameNode>> hitFrameNodes;
183 hitFrameNodes.push_back(frameNode);
184 auto draggedNode = dragDropManager->draggedFrameNode_;
185 auto preTargetNode = dragDropManager->preTargetFrameNode_;
186 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
187 ASSERT_TRUE(draggedNode);
188 ASSERT_TRUE(preTargetNode);
189 }
190
191 /**
192 * @tc.name: DragDropManagerFindTargetInChildNodesTest003
193 * @tc.desc: Test FindTargetInChildNodes
194 * @tc.type: FUNC
195 * @tc.author:
196 */
197 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFindTargetInChildNodesTest003, TestSize.Level1)
198 {
199 /**
200 * @tc.steps: step1. construct a DragDropManager
201 */
202 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
203
204 /**
205 * @tc.steps: step2. call OnDragStart
206 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
207 */
208 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
209 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
210 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
211 customNode->SetActive(true);
212 std::vector<RefPtr<FrameNode>> hitFrameNodes;
213 hitFrameNodes.push_back(frameNode);
214 auto draggedNode = dragDropManager->draggedFrameNode_;
215 auto preTargetNode = dragDropManager->preTargetFrameNode_;
216 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
217 ASSERT_TRUE(draggedNode);
218 ASSERT_TRUE(preTargetNode);
219 }
220
221 /**
222 * @tc.name: DragDropManagerFindTargetInChildNodesTest005
223 * @tc.desc: Test FindTargetInChildNodes
224 * @tc.type: FUNC
225 * @tc.author:
226 */
227 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFindTargetInChildNodesTest005, TestSize.Level1)
228 {
229 /**
230 * @tc.steps: step1. construct a DragDropManager
231 */
232 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
233 RefPtr<UINode> customNode1 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
234 RefPtr<UINode> customNode2 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
235 RefPtr<UINode> customNode3 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
236 std::list<RefPtr<UINode>> child = { customNode1, customNode2, customNode2, nullptr };
237
238 /**
239 * @tc.steps: step2. call OnDragStart
240 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
241 */
242 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
243 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
244 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
245 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
246 customNode->SetActive(true);
247 customNode->children_ = child;
248 std::vector<RefPtr<FrameNode>> hitFrameNodes = { frameNode, frameNode2 };
249 auto draggedNode = dragDropManager->draggedFrameNode_;
250 auto preTargetNode = dragDropManager->preTargetFrameNode_;
251 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
252 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, false);
253 ASSERT_TRUE(draggedNode);
254 ASSERT_TRUE(preTargetNode);
255 }
256
257 /**
258 * @tc.name: DragDropManagerFindTargetInChildNodesTest006
259 * @tc.desc: Test FindTargetInChildNodes
260 * @tc.type: FUNC
261 * @tc.author:
262 */
263 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFindTargetInChildNodesTest006, TestSize.Level1)
264 {
265 /**
266 * @tc.steps: step1. construct a DragDropManager
267 */
268 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
269 RefPtr<UINode> customNode1 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
270 RefPtr<UINode> customNode2 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
271 RefPtr<UINode> customNode3 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
272 std::list<RefPtr<UINode>> child = { customNode1, customNode2, customNode2, nullptr };
273
274 /**
275 * @tc.steps: step2. call OnDragStart
276 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
277 */
278 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
279 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
280 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
281 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
282 customNode->SetActive(true);
283 customNode->children_ = child;
284
285 auto frameNode4 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
286 auto eventHub = frameNode4->GetOrCreateEventHub<EventHub>();
287 std::string onDropInfo;
__anone0ed85120102(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 288 auto onDrop = [&onDropInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* info */) {
289 onDropInfo = EXTRA_INFO;
290 };
291 eventHub->SetOnDrop(std::move(onDrop));
292
293 auto frameNode5 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<GridPattern>());
294 auto gridEvent = frameNode5->GetOrCreateEventHub<GridEventHub>();
295 std::string onItemDropInfo;
296 ItemDropFunc onItemDrop = [&onItemDropInfo](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */,
__anone0ed85120202(const ItemDragInfo& , int32_t , int32_t , bool ) 297 int32_t /* insertIndex */, bool /* isSuccess */) { onItemDropInfo = EXTRA_INFO; };
298 gridEvent->SetOnItemDrop(std::move(onItemDrop));
299
300 std::vector<RefPtr<FrameNode>> hitFrameNodes = { frameNode, frameNode2, frameNode4, frameNode5 };
301 auto draggedNode = dragDropManager->draggedFrameNode_;
302 auto preTargetNode = dragDropManager->preTargetFrameNode_;
303
304 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
305 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, false);
306 ASSERT_TRUE(draggedNode);
307 ASSERT_TRUE(preTargetNode);
308 }
309
310 /**
311 * @tc.name: DragDropManagerFindTargetInChildNodesTest008
312 * @tc.desc: Test FindTargetInChildNodes
313 * @tc.type: FUNC
314 * @tc.author:
315 */
316 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFindTargetInChildNodesTest008, TestSize.Level1)
317 {
318 /**
319 * @tc.steps: step1. construct a DragDropManager
320 */
321 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
322 RefPtr<UINode> customNode1 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
323 RefPtr<UINode> customNode2 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
324 RefPtr<UINode> customNode3 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
325 std::list<RefPtr<UINode>> child = { customNode1, customNode2, customNode2, nullptr };
326
327 /**
328 * @tc.steps: step2. call OnDragStart
329 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
330 */
331 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
332 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
333 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
334 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
335 customNode->SetActive(true);
336 customNode->children_ = child;
337
338 auto parentFrameNode = AceType::DynamicCast<FrameNode>(customNode);
339
340 std::vector<RefPtr<FrameNode>> hitFrameNodes = { parentFrameNode };
341 auto draggedNode = dragDropManager->draggedFrameNode_;
342 auto preTargetNode = dragDropManager->preTargetFrameNode_;
343
344 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
345 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, false);
346 ASSERT_TRUE(draggedNode);
347 ASSERT_TRUE(preTargetNode);
348
349 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
350 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, false);
351 ASSERT_TRUE(draggedNode);
352
353 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
354 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, false);
355 ASSERT_TRUE(draggedNode);
356
357 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, true);
358 dragDropManager->FindTargetInChildNodes(customNode, hitFrameNodes, false);
359 ASSERT_TRUE(draggedNode);
360 ASSERT_TRUE(preTargetNode);
361 }
362
363 /**
364 * @tc.name: DragDropManagerOnDragMoveTest001
365 * @tc.desc: Test OnDragMove
366 * @tc.type: FUNC
367 * @tc.author:
368 */
369 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerOnDragMoveTest001, TestSize.Level1)
370 {
371 /**
372 * @tc.steps: step1. construct a DragDropManager
373 */
374 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
375 DragPointerEvent point;
376
377 /**
378 * @tc.steps: step2. call OnDragStart
379 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
380 */
381 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
382 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
383 auto draggedNode = dragDropManager->draggedFrameNode_;
384 auto preTargetNode = dragDropManager->preTargetFrameNode_;
385 dragDropManager->OnDragMove(point, EXTRA_INFO);
386 ASSERT_TRUE(draggedNode);
387 ASSERT_TRUE(preTargetNode);
388 }
389
390 /**
391 * @tc.name: DragDropManagerFireOnDragEventTest001
392 * @tc.desc: Test FireOnDragEvent
393 * @tc.type: FUNC
394 * @tc.author:
395 */
396 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFireOnDragEventTest001, TestSize.Level1)
397 {
398 /**
399 * @tc.steps: step1. construct a DragDropManager
400 */
401 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
402
403 /**
404 * @tc.steps: step2. call FindDragFrameNodeByPosition with frameNodes contains nullptr
405 * @tc.expected: step2.
406 */
407 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
408 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
409 frameNodeNull.Reset();
410 auto frameNodeGeoNullId = ElementRegister::GetInstance()->MakeUniqueId();
411 auto frameNodeGeoNull =
412 AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeGeoNullId, AceType::MakeRefPtr<Pattern>());
413 frameNodeGeoNull->SetGeometryNode(nullptr);
414 auto targetFrameNode = dragDropManager->FindDragFrameNodeByPosition(GLOBAL_X, GLOBAL_Y);
415 EXPECT_FALSE(targetFrameNode);
416
417 /**
418 * @tc.steps: step3. call FireOnDragEvent with type=DragEventType::DROP
419 * @tc.expected: step3. FireOnDrop will be called
420 */
421 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
422 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
423 std::string onDropInfo;
__anone0ed85120302(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 424 auto onDrop = [&onDropInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* info */) {
425 onDropInfo = EXTRA_INFO;
426 };
427 eventHub->SetOnDrop(std::move(onDrop));
428 DragPointerEvent point;
429 TouchEvent event;
430 event.x = 1.0f;
431 event.y = 2.0f;
432 dragDropManager->velocityTracker_.UpdateTouchPoint(event, false);
433 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::ENTER, EXTRA_INFO);
434 EXPECT_EQ(onDropInfo, "");
435 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::MOVE, EXTRA_INFO);
436 EXPECT_EQ(onDropInfo, "");
437 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::LEAVE, EXTRA_INFO);
438 EXPECT_EQ(onDropInfo, "");
439 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::START, EXTRA_INFO);
440 EXPECT_EQ(onDropInfo, "");
441
442 /**
443 * @tc.steps: step4. call FireOnDragEvent with UIExtensionComponent
444 * @tc.expected: step4. FireOnDrop will be called
445 */
446 auto UIExtensionComponent =
447 AceType::MakeRefPtr<FrameNode>(V2::DYNAMIC_COMPONENT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
448 ASSERT_NE(UIExtensionComponent, nullptr);
449 dragDropManager->FireOnDragEvent(UIExtensionComponent, point, DragEventType::START, EXTRA_INFO);
450 EXPECT_EQ(onDropInfo, "");
451 }
452
453 /**
454 * @tc.name: DragDropManagerFireOnItemDragEventTest003
455 * @tc.desc: Test FireOnItemDragEvent
456 * @tc.type: FUNC
457 * @tc.author:
458 */
459 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFireOnItemDragEventTest003, TestSize.Level1)
460 {
461 /**
462 * @tc.steps: step1. construct a DragDropManager
463 */
464 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
465
466 /**
467 * @tc.steps: step2. call FindDragFrameNodeByPosition with frameNodes contains nullptr
468 * @tc.expected: step2.
469 */
470 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
471 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
472 frameNodeNull.Reset();
473 auto frameNodeGeoNullId = ElementRegister::GetInstance()->MakeUniqueId();
474 auto frameNodeGeoNull =
475 AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeGeoNullId, AceType::MakeRefPtr<Pattern>());
476 frameNodeGeoNull->SetGeometryNode(nullptr);
477 auto targetFrameNode = dragDropManager->FindDragFrameNodeByPosition(GLOBAL_X, GLOBAL_Y);
478 EXPECT_FALSE(targetFrameNode);
479
480 /**
481 * @tc.steps: step3. call FireOnDragEvent with type=DragEventType::DROP
482 * @tc.expected: step3. FireOnDrop will be called
483 */
484 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
485 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
486 std::string onDropInfo;
__anone0ed85120402(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 487 auto onDrop = [&onDropInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* info */) {
488 onDropInfo = EXTRA_INFO;
489 };
490 eventHub->SetOnDrop(std::move(onDrop));
491 DragPointerEvent point;
492 TouchEvent event;
493 event.x = 1.0f;
494 event.y = 2.0f;
495 dragDropManager->velocityTracker_.UpdateTouchPoint(event, false);
496 OHOS::Ace::ItemDragInfo itemDragInfo;
497 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::ENTER, EXTRA_INFO);
498 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::ENTER, 0, 0);
499 EXPECT_EQ(onDropInfo, "");
500 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::MOVE, 0, 0);
501 EXPECT_EQ(onDropInfo, "");
502 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::START, 0, 0);
503 EXPECT_EQ(onDropInfo, "");
504 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::ENTER, 0, 0);
505 EXPECT_EQ(onDropInfo, "");
506 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::START, 0, 0);
507 EXPECT_EQ(onDropInfo, "");
508 dragDropManager->FireOnItemDragEvent(frameNode, DragType::TEXT, itemDragInfo, DragEventType::START, 0, 0);
509 EXPECT_EQ(onDropInfo, "");
510 }
511
512 /**
513 * @tc.name: DragDropManagerOnItemDragEndTest001
514 * @tc.desc: Test OnItemDragEnd
515 * @tc.type: FUNC
516 * @tc.author:
517 */
518 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerOnItemDragEndTest001, TestSize.Level1)
519 {
520 /**
521 * @tc.steps: step1. construct a DragDropManager
522 */
523 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
524
525 /**
526 * @tc.steps: step2. call OnDragStart
527 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
528 */
529 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
530 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
531 auto draggedNode = dragDropManager->draggedFrameNode_;
532 auto preTargetNode = dragDropManager->preTargetFrameNode_;
533 dragDropManager->draggedGridFrameNode_ = frameNode;
534 dragDropManager->OnItemDragEnd(0.0, 0.0, 0, DragType::COMMON);
535 ASSERT_TRUE(draggedNode);
536 ASSERT_TRUE(preTargetNode);
537 dragDropManager->OnItemDragEnd(0.0, 0.0, 0, DragType::GRID);
538 ASSERT_TRUE(draggedNode);
539 ASSERT_TRUE(preTargetNode);
540 }
541
542 /**
543 * @tc.name: DragDropManagerFireOnItemDragEventTest001
544 * @tc.desc: Test FireOnItemDragEvent
545 * @tc.type: FUNC
546 * @tc.author:
547 */
548 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFireOnItemDragEventTest001, TestSize.Level1)
549 {
550 /**
551 * @tc.steps: step1. construct a DragDropManager
552 */
553 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
554
555 /**
556 * @tc.steps: step2. call FindDragFrameNodeByPosition with frameNodes contains nullptr
557 * @tc.expected: step2.
558 */
559 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
560 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
561 frameNodeNull.Reset();
562 auto frameNodeGeoNullId = ElementRegister::GetInstance()->MakeUniqueId();
563 auto frameNodeGeoNull =
564 AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeGeoNullId, AceType::MakeRefPtr<Pattern>());
565 frameNodeGeoNull->SetGeometryNode(nullptr);
566 auto targetFrameNode = dragDropManager->FindDragFrameNodeByPosition(GLOBAL_X, GLOBAL_Y);
567 EXPECT_FALSE(targetFrameNode);
568
569 /**
570 * @tc.steps: step3. call FireOnDragEvent with type=DragEventType::DROP
571 * @tc.expected: step3. FireOnDrop will be called
572 */
573 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
574 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
575 std::string onDropInfo;
__anone0ed85120502(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 576 auto onDrop = [&onDropInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* info */) {
577 onDropInfo = EXTRA_INFO;
578 };
579 eventHub->SetOnDrop(std::move(onDrop));
580 TouchEvent event;
581 event.x = 1.0f;
582 event.y = 2.0f;
583 dragDropManager->velocityTracker_.UpdateTouchPoint(event, false);
584 OHOS::Ace::ItemDragInfo itemDragInfo;
585 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::ENTER, 0, 0);
586 EXPECT_EQ(onDropInfo, "");
587 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::MOVE, 0, 0);
588 EXPECT_EQ(onDropInfo, "");
589 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::START, 0, 0);
590 EXPECT_EQ(onDropInfo, "");
591 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::ENTER, 0, 0);
592 EXPECT_EQ(onDropInfo, "");
593 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::START, 0, 0);
594 EXPECT_EQ(onDropInfo, "");
595 dragDropManager->FireOnItemDragEvent(frameNode, DragType::TEXT, itemDragInfo, DragEventType::START, 0, 0);
596 EXPECT_EQ(onDropInfo, "");
597 }
598
599 /**
600 * @tc.name: DragDropManagerFireOnItemDragEventTest002
601 * @tc.desc: Test FireOnItemDragEvent
602 * @tc.type: FUNC
603 * @tc.author:
604 */
605 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFireOnItemDragEventTest002, TestSize.Level1)
606 {
607 /**
608 * @tc.steps: step1. construct a DragDropManager
609 */
610 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
611
612 /**
613 * @tc.steps: step2. construct a frameNode whose tag is List set its ItemDragEvent and GeometryNode
614 */
615 auto frameNode = AceType::MakeRefPtr<FrameNode>(LIST_TAG, -1, AceType::MakeRefPtr<ListPattern>());
616 auto eventHub = frameNode->GetOrCreateEventHub<ListEventHub>();
617
618 // Set OnItemDragLeave callback
619 std::string itemInfoLeave;
__anone0ed85120602(const ItemDragInfo& , int32_t ) 620 auto onItemDragLeave = [&itemInfoLeave](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */) {
621 itemInfoLeave = ITEM_INFO_LEAVE;
622 };
623 eventHub->SetOnItemDragLeave(std::move(onItemDragLeave));
624
625 // Set OnItemDragMove callback
626 std::string itemInfoMove;
627 auto onItemDragMove = [&itemInfoMove](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */,
__anone0ed85120702(const ItemDragInfo& , int32_t , int32_t ) 628 int32_t /* insertIndex */) { itemInfoMove = ITEM_INFO_MOVE; };
629 eventHub->SetOnItemDragMove(std::move(onItemDragMove));
630
631 // Set OnItemDragEnter callback
632 std::string itemInfoEnter;
__anone0ed85120802(const ItemDragInfo& ) 633 auto onItemDragEnter = [&itemInfoEnter](const ItemDragInfo& /* dragInfo */) { itemInfoEnter = ITEM_INFO_ENTER; };
634 eventHub->SetOnItemDragEnter(std::move(onItemDragEnter));
635
636 // Set geometry node to make sure (GLOBAL_X, GLOBAL_Y) in geoNode.frameRect_
637 auto geoNode = AceType::MakeRefPtr<GeometryNode>();
638 geoNode->SetMarginFrameOffset(FRAME_OFFSET);
639 geoNode->SetFrameSize(FRAME_SIZE);
640 frameNode->SetGeometryNode(geoNode);
641
642 /**
643 * @tc.steps: step3. call OnItemDragMove
644 * case: listDragFrameNodes_ is empty & preGridTargetFrameNode_ is not null
645 * @tc.expected: step3. frameNode's onItemDragLeave_ will be called
646 * itemInfoLeave will be assigned to ITEM_INFO_LEAVE
647 */
648 dragDropManager->OnItemDragStart(GLOBAL_X, GLOBAL_Y, frameNode);
649 auto preGridTargetNode = dragDropManager->preGridTargetFrameNode_;
650 dragDropManager->OnItemDragMove(GLOBAL_X, GLOBAL_Y, DRAGGED_INDEX, DRAG_TYPE_LIST);
651 preGridTargetNode = dragDropManager->preGridTargetFrameNode_;
652 dragDropManager->AddGridDragFrameNode(frameNode->GetId(), frameNode);
653
654 dragDropManager->OnItemDragStart(GLOBAL_X, GLOBAL_Y, frameNode);
655 preGridTargetNode = dragDropManager->preGridTargetFrameNode_;
656 dragDropManager->OnItemDragMove(GLOBAL_X, GLOBAL_Y, DRAGGED_INDEX, DRAG_TYPE_LIST);
657 // to force call the FireOnItemDragEvent with DragType::LIST and DragEventType::MOVE
658 OHOS::Ace::ItemDragInfo itemDragInfo;
659 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::MOVE, DRAGGED_INDEX);
660 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::ENTER, DRAGGED_INDEX);
661 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::START, DRAGGED_INDEX);
662 EXPECT_EQ(itemInfoMove, ITEM_INFO_MOVE);
663 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::ENTER, DRAGGED_INDEX);
664 EXPECT_EQ(itemInfoMove, ITEM_INFO_MOVE);
665 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::MOVE, DRAGGED_INDEX);
666 EXPECT_EQ(itemInfoMove, ITEM_INFO_MOVE);
667 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::START, DRAGGED_INDEX);
668 EXPECT_EQ(itemInfoMove, ITEM_INFO_MOVE);
669 }
670
671 /**
672 * @tc.name: DragDropManagerFireOnItemDropEventTest001
673 * @tc.desc: Test FireOnItemDropEvent
674 * @tc.type: FUNC
675 * @tc.author:
676 */
677 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFireOnItemDropEventTest001, TestSize.Level1)
678 {
679 /**
680 * @tc.steps: step1. construct a DragDropManager
681 */
682 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
683
684 /**
685 * @tc.steps: step2. call OnDragStart
686 * @tc.expected: step2. FireOnItemDropEvent
687 */
688 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
689 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
690 auto draggedNode = dragDropManager->draggedFrameNode_;
691 auto preTargetNode = dragDropManager->preTargetFrameNode_;
692 dragDropManager->draggedGridFrameNode_ = frameNode;
693 dragDropManager->OnItemDragEnd(0.0, 0.0, 0, DragType::COMMON);
694 ASSERT_TRUE(draggedNode);
695 ASSERT_TRUE(preTargetNode);
696 OHOS::Ace::ItemDragInfo itemDragInfo;
697 dragDropManager->FireOnItemDropEvent(frameNode, DragType::TEXT, itemDragInfo, 0, 0, true);
698 ASSERT_TRUE(draggedNode);
699 ASSERT_TRUE(preTargetNode);
700 }
701
702 /**
703 * @tc.name: DragDropManagerGetItemIndexTest001
704 * @tc.desc: Test GetItemIndex
705 * @tc.type: FUNC
706 * @tc.author:
707 */
708 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerGetItemIndexTest001, TestSize.Level1)
709 {
710 /**
711 * @tc.steps: step1. construct a DragDropManager
712 */
713 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
714
715 /**
716 * @tc.steps: step2. call OnDragStart
717 * @tc.expected: step2. FireOnItemDropEvent
718 */
719 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
720 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
721 auto draggedNode = dragDropManager->draggedFrameNode_;
722 auto preTargetNode = dragDropManager->preTargetFrameNode_;
723
724 dragDropManager->OnItemDragEnd(0.0, 0.0, 0, DragType::COMMON);
725 ASSERT_TRUE(draggedNode);
726 ASSERT_TRUE(preTargetNode);
727 OHOS::Ace::ItemDragInfo itemDragInfo;
728 dragDropManager->GetItemIndex(frameNode, DragType::TEXT, 0.0, 0.0);
729 ASSERT_TRUE(draggedNode);
730 dragDropManager->GetItemIndex(frameNode, DragType::COMMON, 0.0, 0.0);
731 ASSERT_TRUE(draggedNode);
732 dragDropManager->GetItemIndex(frameNode, DragType::GRID, 0.0, 0.0);
733 ASSERT_TRUE(draggedNode);
734 dragDropManager->draggedGridFrameNode_ = frameNode;
735 dragDropManager->GetItemIndex(frameNode, DragType::GRID, 0.0, 0.0);
736 ASSERT_TRUE(draggedNode);
737 }
738 /**
739 * @tc.name: DragDropManagerGetItemIndexTest002
740 * @tc.desc: Test GetItemIndex
741 * @tc.type: FUNC
742 * @tc.author:
743 */
744 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerGetItemIndexTest002, TestSize.Level1)
745 {
746 /**
747 * @tc.steps: step1. construct a DragDropManager
748 */
749 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
750
751 /**
752 * @tc.steps: step2. call FindDragFrameNodeByPosition with frameNodes contains nullptr
753 * @tc.expected: step2.
754 */
755 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
756 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
757 frameNodeNull.Reset();
758 auto frameNodeGeoNullId = ElementRegister::GetInstance()->MakeUniqueId();
759 auto frameNodeGeoNull =
760 AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeGeoNullId, AceType::MakeRefPtr<Pattern>());
761 frameNodeGeoNull->SetGeometryNode(nullptr);
762 auto targetFrameNode = dragDropManager->FindDragFrameNodeByPosition(GLOBAL_X, GLOBAL_Y);
763 /**
764 * @tc.steps: step3. call FireOnDragEvent with type=DragEventType::DROP
765 * @tc.expected: step3. FireOnDrop will be called
766 */
767 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
768 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
769 std::string onDropInfo;
__anone0ed85120902(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 770 auto onDrop = [&onDropInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* info */) {
771 onDropInfo = EXTRA_INFO;
772 };
773 eventHub->SetOnDrop(std::move(onDrop));
774 DragPointerEvent point;
775 TouchEvent event;
776 event.x = 1.0f;
777 event.y = 2.0f;
778 dragDropManager->velocityTracker_.UpdateTouchPoint(event, false);
779 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::DROP, EXTRA_INFO);
780
781 /**
782 * @tc.steps: step4. call FireOnItemDropEvent with type=DragEventType::DROP
783 * @tc.expected: step4. FireOnItemDrop will be called
784 */
785 ItemDragInfo itemDragInfo;
786 auto gridNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<GridPattern>());
787 auto gridEvent = gridNode->GetOrCreateEventHub<GridEventHub>();
788 std::string onItemDropInfo;
789 ItemDropFunc onItemDrop = [&onItemDropInfo](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */,
__anone0ed85120a02(const ItemDragInfo& , int32_t , int32_t , bool ) 790 int32_t /* insertIndex */, bool /* isSuccess */) { onItemDropInfo = EXTRA_INFO; };
791 gridEvent->SetOnItemDrop(std::move(onItemDrop));
792 dragDropManager->GetItemIndex(gridNode, DragType::GRID, 0.0, 0.0);
793 auto listNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<ListPattern>());
794 auto listEvent = listNode->GetOrCreateEventHub<ListEventHub>();
795 std::string onItemDropInfoList;
796 ItemDropFunc onItemDropList = [&onItemDropInfoList](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */,
797 int32_t /* insertIndex */,
__anone0ed85120b02(const ItemDragInfo& , int32_t , int32_t , bool ) 798 bool /* isSuccess */) { onItemDropInfoList = EXTRA_INFO; };
799 listEvent->SetOnItemDrop(std::move(onItemDropList));
800 dragDropManager->GetItemIndex(listNode, DragType::GRID, 0.0, 0.0);
801 dragDropManager->GetItemIndex(listNode, DragType::COMMON, 0.0, 0.0);
802 dragDropManager->GetItemIndex(listNode, DragType::TEXT, 0.0, 0.0);
803 dragDropManager->GetItemIndex(listNode, DragType::LIST, 0.0, 0.0);
804 EXPECT_EQ(onItemDropInfoList, "");
805 }
806
807 /**
808 * @tc.name: DragDropManagerGetItemIndexTest003
809 * @tc.desc: Test GetItemIndex
810 * @tc.type: FUNC
811 * @tc.author:
812 */
813 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerGetItemIndexTest003, TestSize.Level1)
814 {
815 /**
816 * @tc.steps: step1. construct a DragDropManager
817 */
818 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
819
820 /**
821 * @tc.steps: step2. call FindDragFrameNodeByPosition with frameNodes contains nullptr
822 * @tc.expected: step2.
823 */
824 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
825 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
826 frameNodeNull.Reset();
827 auto frameNodeGeoNullId = ElementRegister::GetInstance()->MakeUniqueId();
828 auto frameNodeGeoNull =
829 AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeGeoNullId, AceType::MakeRefPtr<Pattern>());
830 frameNodeGeoNull->SetGeometryNode(nullptr);
831 auto targetFrameNode = dragDropManager->FindDragFrameNodeByPosition(GLOBAL_X, GLOBAL_Y);
832
833 /**
834 * @tc.steps: step3. call FireOnDragEvent with type=DragEventType::DROP
835 * @tc.expected: step3. FireOnDrop will be called
836 */
837 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
838 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
839 std::string onDropInfo;
__anone0ed85120c02(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 840 auto onDrop = [&onDropInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* info */) {
841 onDropInfo = EXTRA_INFO;
842 };
843 eventHub->SetOnDrop(std::move(onDrop));
844 DragPointerEvent point;
845 TouchEvent event;
846 event.x = 1.0f;
847 event.y = 2.0f;
848 dragDropManager->velocityTracker_.UpdateTouchPoint(event, false);
849 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::DROP, EXTRA_INFO);
850
851 /**
852 * @tc.steps: step4. call FireOnItemDropEvent with type=DragEventType::DROP
853 * @tc.expected: step4. FireOnItemDrop will be called
854 */
855 ItemDragInfo itemDragInfo;
856 auto gridNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<GridPattern>());
857 auto gridEvent = gridNode->GetOrCreateEventHub<GridEventHub>();
858 std::string onItemDropInfo;
859 ItemDropFunc onItemDrop = [&onItemDropInfo](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */,
__anone0ed85120d02(const ItemDragInfo& , int32_t , int32_t , bool ) 860 int32_t /* insertIndex */, bool /* isSuccess */) { onItemDropInfo = EXTRA_INFO; };
861 gridEvent->SetOnItemDrop(std::move(onItemDrop));
862 dragDropManager->draggedGridFrameNode_ = gridNode;
863 dragDropManager->GetItemIndex(gridNode, DragType::GRID, 0.0, 0.0);
864 auto listNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<ListPattern>());
865 auto listEvent = listNode->GetOrCreateEventHub<ListEventHub>();
866 std::string onItemDropInfoList;
867 ItemDropFunc onItemDropList = [&onItemDropInfoList](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */,
868 int32_t /* insertIndex */,
__anone0ed85120e02(const ItemDragInfo& , int32_t , int32_t , bool ) 869 bool /* isSuccess */) { onItemDropInfoList = EXTRA_INFO; };
870 listEvent->SetOnItemDrop(std::move(onItemDropList));
871 dragDropManager->draggedGridFrameNode_ = gridNode;
872 dragDropManager->GetItemIndex(listNode, DragType::GRID, 0.0, 0.0);
873 dragDropManager->GetItemIndex(listNode, DragType::GRID, 1.0f, 2.0f);
874 EXPECT_EQ(onItemDropInfoList, "");
875 }
876
877 /**
878 * @tc.name: DragDropManagerFireOnEditableTextComponent
879 * @tc.desc: Test FireOnEditableTextComponent
880 * @tc.type: FUNC
881 * @tc.author:
882 */
883 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerFireOnEditableTextComponent, TestSize.Level1)
884 {
885 /**
886 * @tc.steps: step1. construct a DragDropManager and create a point.
887 */
888 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
889
890 /**
891 * @tc.steps: step2. Create a normal frameNode which is not a editable text component,
892 * and test FireOnEditableTextComponent.
893 * @tc.expected: step2.
894 */
895 {
896 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
897 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::ENTER);
898 }
899
900 /**
901 * @tc.steps: step3. Create a editable text component, and test FireOnEditableTextComponent.
902 * @tc.expected: step3.
903 */
904 {
905 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXTINPUT_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
906 #ifdef ENABLE_DRAG_FRAMEWORK
907 EXPECT_CALL(*(AceType::DynamicCast<MockInteractionInterface>(MockInteractionInterface::GetInstance())),
908 EnterTextEditorArea(_))
909 .Times(1)
910 .WillOnce(::testing::Return(0));
911 #else
912 EXPECT_CALL(*(AceType::DynamicCast<MockInteractionInterface>(MockInteractionInterface::GetInstance())),
913 EnterTextEditorArea(_))
914 .Times(1);
915 #endif // ENABLE_DRAG_FRAMEWORK
916 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::ENTER);
917 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::ENTER);
918 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::MOVE);
919 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::LEAVE);
920 }
921 }
922
923 /**
924 * @tc.name: DragDropManagerClearVelocityInfoTest001
925 * @tc.desc: Test ClearVelocityInfo
926 * @tc.type: FUNC
927 * @tc.author:
928 */
929 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerClearVelocityInfoTest001, TestSize.Level1)
930 {
931 /**
932 * @tc.steps: step1. construct a DragDropManager
933 */
934 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
935
936 /**
937 * @tc.steps: step2. call OnDragStart
938 * @tc.expected: step2. FireOnItemDropEvent
939 */
940 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
941 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
942 auto draggedNode = dragDropManager->draggedFrameNode_;
943 auto preTargetNode = dragDropManager->preTargetFrameNode_;
944
945 dragDropManager->OnItemDragEnd(0.0, 0.0, 0, DragType::COMMON);
946 EXPECT_TRUE(draggedNode);
947 EXPECT_TRUE(preTargetNode);
948 OHOS::Ace::ItemDragInfo itemDragInfo;
949 dragDropManager->GetItemIndex(frameNode, DragType::TEXT, 0.0, 0.0);
950 EXPECT_TRUE(draggedNode);
951 dragDropManager->GetItemIndex(frameNode, DragType::COMMON, 0.0, 0.0);
952 EXPECT_TRUE(draggedNode);
953 dragDropManager->GetItemIndex(frameNode, DragType::GRID, 0.0, 0.0);
954 EXPECT_TRUE(draggedNode);
955 dragDropManager->draggedGridFrameNode_ = frameNode;
956 dragDropManager->GetItemIndex(frameNode, DragType::GRID, 0.0, 0.0);
957 dragDropManager->ClearVelocityInfo();
958 EXPECT_TRUE(draggedNode);
959 }
960
961 /**
962 * @tc.name: DragDropManagerClearExtraInfoTest001
963 * @tc.desc: Test ClearExtraInfo
964 * @tc.type: FUNC
965 * @tc.author:
966 */
967 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerClearExtraInfoTest001, TestSize.Level1)
968 {
969 /**
970 * @tc.steps: step1. construct a DragDropManager
971 */
972 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
973
974 /**
975 * @tc.steps: step2. call OnDragStart
976 * @tc.expected: step2. FireOnItemDropEvent
977 */
978 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
979 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
980 auto draggedNode = dragDropManager->draggedFrameNode_;
981
982 dragDropManager->ClearExtraInfo();
983 EXPECT_TRUE(draggedNode);
984 }
985
986 /**
987 * @tc.name: DragDropManagerSetExtraInfoTest001
988 * @tc.desc: Test SetExtraInfo
989 * @tc.type: FUNC
990 * @tc.author:
991 */
992 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerSetExtraInfoTest001, TestSize.Level1)
993 {
994 /**
995 * @tc.steps: step1. construct a DragDropManager
996 */
997 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
998
999 /**
1000 * @tc.steps: step2. call OnDragStart
1001 * @tc.expected: step2. FireOnItemDropEvent
1002 */
1003 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1004 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
1005
1006 dragDropManager->SetExtraInfo("ExtraInfo");
1007 EXPECT_EQ(dragDropManager->GetExtraInfo(), "ExtraInfo");
1008 }
1009
1010 /**
1011 * @tc.name: DragDropProxyOnDragEndTest002
1012 * @tc.desc: OnDragEnd
1013 * @tc.type: FUNC
1014 * @tc.author:
1015 */
1016 HWTEST_F(DragDropManagerTestNgNew, DragDropProxyOnDragEndTest002, TestSize.Level1)
1017 {
1018 /**
1019 * @tc.steps: step1. construct a DragDropManager
1020 */
1021 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1022
1023 /**
1024 * @tc.steps: step2. call CreateFrameworkDragDropProxy
1025 * @tc.expected: step2. return a dragDropProxy successfully
1026 */
1027 GestureEvent gestureEvent;
1028 auto dragDropProxy = dragDropManager->CreateFrameworkDragDropProxy();
1029 dragDropProxy->OnDragEnd(gestureEvent, true);
1030 EXPECT_TRUE(dragDropProxy);
1031 dragDropProxy->OnDragEnd(gestureEvent, false);
1032 EXPECT_TRUE(dragDropProxy);
1033 }
1034
1035 /**
1036 * @tc.name: DragDropProxyDestroyDragWindowTest001
1037 * @tc.desc: DestroyDragWindow
1038 * @tc.type: FUNC
1039 * @tc.author:
1040 */
1041 HWTEST_F(DragDropManagerTestNgNew, DragDropProxyDestroyDragWindowTest001, TestSize.Level1)
1042 {
1043 /**
1044 * @tc.steps: step1. construct a DragDropManager
1045 */
1046 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1047
1048 /**
1049 * @tc.steps: step2. call CreateFrameworkDragDropProxy
1050 * @tc.expected: step2. return a dragDropProxy successfully
1051 */
1052 GestureEvent gestureEvent;
1053 auto dragDropProxy = dragDropManager->CreateFrameworkDragDropProxy();
1054 dragDropProxy->DestroyDragWindow();
1055 EXPECT_TRUE(dragDropProxy);
1056 }
1057
1058 /**
1059 * @tc.name: DragDropProxyOnDragEndTest003
1060 * @tc.desc: OnDragEnd
1061 * @tc.type: FUNC
1062 * @tc.author:
1063 */
1064 HWTEST_F(DragDropManagerTestNgNew, DragDropProxyOnDragEndTest003, TestSize.Level1)
1065 {
1066 /**
1067 * @tc.steps: step1. construct a DragDropManager
1068 */
1069 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1070
1071 /**
1072 * @tc.steps: step2. call CreateFrameworkDragDropProxy
1073 * @tc.expected: step2. return a dragDropProxy successfully
1074 */
1075 GestureEvent gestureEvent;
1076 auto dragDropProxy = dragDropManager->CreateFrameworkDragDropProxy();
1077 EXPECT_TRUE(dragDropProxy);
1078
1079 /**
1080 * @tc.steps: step3. call AddDataToClipboard
1081 * @tc.expected: step3. ClipBoard.SetData() & ClipBoard.GetData() will be called with printing logs
1082 * they're defined in "components_ng/test/mock/clipboard/mock_clipboard.cpp"
1083 */
1084 dragDropManager->AddDataToClipboard(EXTRA_INFO);
1085
1086 /**
1087 * @tc.steps: step4. call GetExtraInfoFromClipboard after calling AddDataToClipboard
1088 * @tc.expected: step4. get the extraInfo successfully
1089 * ClipBoard.GetData() will be called with printing a log
1090 * it's defined in "components_ng/test/mock/clipboard/mock_clipboard.cpp"
1091 */
1092 std::string extraInfo;
1093 dragDropManager->GetExtraInfoFromClipboard(extraInfo);
1094 EXPECT_EQ(extraInfo, EXTRA_INFO);
1095 dragDropProxy->OnDragEnd(gestureEvent, true);
1096 EXPECT_TRUE(dragDropProxy);
1097 dragDropProxy->OnDragEnd(gestureEvent, false);
1098 EXPECT_TRUE(dragDropProxy);
1099 }
1100
1101 /**
1102 * @tc.name: DragDropManagerTest042
1103 * @tc.desc: Test DoDragStartAnimation with RefPtr<OverlayManager>& overlayManager and GestureEvent
1104 * @tc.type: FUNC
1105 * @tc.author:
1106 */
1107 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest042, TestSize.Level1)
1108 {
1109 /**
1110 * @tc.steps: step1. construct a DragDropManager.
1111 * @tc.expected: dragDropManager is not null.
1112 */
1113 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1114 ASSERT_NE(dragDropManager, nullptr);
1115
1116 /**
1117 * @tc.steps: step2. Construct frameNode and overlayManager and update the properties.
1118 * @tc.expected: frameNode and geometryNode are not null.
1119 */
1120 RefPtr<UINode> frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1121 ASSERT_NE(frameNode, nullptr);
1122 auto overlayManager = AceType::MakeRefPtr<OverlayManager>(AceType::DynamicCast<FrameNode>(frameNode));
1123 ASSERT_NE(overlayManager, nullptr);
1124
1125 /**
1126 * @tc.steps: step3. call DoDragStartAnimation into arguments overlayManager and event.
1127 * @tc.expected: retFlag is false.
1128 */
1129 GestureEvent event;
1130 dragDropManager->SetIsDragWithContextMenu(true);
1131 auto frameNode2 = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>(), false);
1132 ASSERT_NE(frameNode2, nullptr);
1133 auto guestureEventHub = frameNode2->GetOrCreateGestureEventHub();
1134 PreparedInfoForDrag drag;
1135 dragDropManager->DoDragStartAnimation(overlayManager, event, guestureEventHub, drag);
1136 dragDropManager->TransDragWindowToDragFwk(111);
1137 bool retFlag = dragDropManager->GetDragPreviewInfo(overlayManager, dragDropManager->info_, guestureEventHub, drag);
1138 EXPECT_FALSE(retFlag);
1139
1140 /**
1141 * @tc.steps: step4. call DoDragStartAnimation into arguments overlayManager and event.
1142 * @tc.expected: retFlag is true.
1143 */
1144 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1145 std::list<RefPtr<UINode>> children = { customNode };
1146 RefPtr<FrameNode> customNodeChild = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1147 customNode->AddChild(customNodeChild);
1148 frameNode->children_ = children;
1149 overlayManager->hasDragPixelMap_ = true;
1150 overlayManager->dragPixmapColumnNodeWeak_ = WeakPtr<FrameNode>(AceType::DynamicCast<FrameNode>(frameNode));
1151 retFlag = dragDropManager->GetDragPreviewInfo(overlayManager, dragDropManager->info_, guestureEventHub, drag);
1152 EXPECT_TRUE(retFlag);
1153
1154 /**
1155 * @tc.steps: step5. call DoDragStartAnimation into arguments overlayManager and event.
1156 * @tc.expected: retFlag is false.
1157 */
1158 dragDropManager->info_.scale = -1.0f;
1159 dragDropManager->DoDragStartAnimation(overlayManager, event, guestureEventHub, drag);
1160 retFlag = dragDropManager->IsNeedScaleDragPreview();
1161 EXPECT_FALSE(retFlag);
1162 }
1163 /**
1164 * @tc.name: DragDropManagerTest043
1165 * @tc.desc: Test DoDragMoveAnimate
1166 * @tc.type: FUNC
1167 * @tc.author:
1168 */
1169 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest043, TestSize.Level1)
1170 {
1171 /**
1172 * @tc.steps: step1. construct a DragDropManager.
1173 * @tc.expected: dragDropManager is not null.
1174 */
1175 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1176 ASSERT_NE(dragDropManager, nullptr);
1177
1178 /**
1179 * @tc.steps: step2. call DoDragMoveAnimate with pointerEvent.
1180 * @tc.expected: dragDropManager->IsNeedScaleDragPreview() returns true.
1181 */
1182 DragPointerEvent pointerEvent;
1183 dragDropManager->info_.scale = 0.5f;
1184 dragDropManager->DoDragMoveAnimate(pointerEvent);
1185 EXPECT_TRUE(dragDropManager->IsNeedScaleDragPreview());
1186
1187 auto subwindow = Subwindow::CreateSubwindow(VALID_CURRENT_ID);
1188 SubwindowManager::GetInstance()->AddSubwindow(VALID_CURRENT_ID, subwindow);
1189
1190 /**
1191 * @tc.steps: step3. call DoDragMoveAnimate with pointerEvent.
1192 * @tc.expected: overlayManager is null.
1193 */
1194 dragDropManager->DoDragMoveAnimate(pointerEvent);
1195 auto overlayManager = subwindow->GetOverlayManager();
1196 ASSERT_EQ(overlayManager, nullptr);
1197 }
1198
1199 /**
1200 * @tc.name: DragDropManagerTest044
1201 * @tc.desc: Test CalcDragMoveOffset
1202 * @tc.type: FUNC
1203 * @tc.author:
1204 */
1205 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest044, TestSize.Level1)
1206 {
1207 /**
1208 * @tc.steps: step1. construct a DragDropManager.
1209 * @tc.expected: dragDropManager is not null.
1210 */
1211 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1212 ASSERT_NE(dragDropManager, nullptr);
1213
1214 /**
1215 * @tc.steps: step2. call CalcDragMoveOffset with Dimension and DragPreviewInfo.
1216 * @tc.expected: dragDropManager->IsNeedScaleDragPreview() return a true value.
1217 */
1218 Dimension preserverHeight;
1219 dragDropManager->info_.scale = 0.5f;
1220 dragDropManager->CalcDragMoveOffset(preserverHeight, 0, 0, dragDropManager->info_);
1221 EXPECT_TRUE(dragDropManager->IsNeedScaleDragPreview());
1222 }
1223
1224 /**
1225 * @tc.name: DragDropManagerTest045
1226 * @tc.desc: Test GetDragPreviewInfo
1227 * @tc.type: FUNC
1228 * @tc.author:
1229 */
1230 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest045, TestSize.Level1)
1231 {
1232 /**
1233 * @tc.steps: step1. construct a DragDropManager.
1234 * @tc.expected: dragDropManager is not null.
1235 */
1236 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1237 ASSERT_NE(dragDropManager, nullptr);
1238
1239 /**
1240 * @tc.steps: step2. Construct frameNode and overlayManager and update the properties.
1241 * @tc.expected: frameNode and overlayManager are not null.
1242 */
1243 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
1244 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
1245 ASSERT_NE(frameNode, nullptr);
1246 auto overlayManager = AceType::MakeRefPtr<OverlayManager>(AceType::DynamicCast<FrameNode>(frameNode));
1247 ASSERT_NE(overlayManager, nullptr);
1248 overlayManager->pixmapColumnNodeWeak_ = nullptr;
1249 overlayManager->SetHasPixelMap(true);
1250
1251 /**
1252 * @tc.steps: step3. call GetDragPreviewInfo with arguments overlayManager and dragDropManager->info_.
1253 * @tc.expected: imageNode is null.
1254 */
1255 auto frameNode2 = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>(), false);
1256 ASSERT_NE(frameNode2, nullptr);
1257 auto guestureEventHub = frameNode2->GetOrCreateGestureEventHub();
1258 PreparedInfoForDrag drag;
1259 dragDropManager->GetDragPreviewInfo(overlayManager, dragDropManager->info_, guestureEventHub, drag);
1260 auto imageNode = overlayManager->GetPixelMapContentNode();
1261 ASSERT_EQ(imageNode, nullptr);
1262 }
1263
1264 /**
1265 * @tc.name: DragDropManagerTest046
1266 * @tc.desc: Test AddDataToClipboard
1267 * @tc.type: FUNC
1268 * @tc.author:
1269 */
1270 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest046, TestSize.Level1)
1271 {
1272 /**
1273 * @tc.steps: step1. Create DragDropManager.
1274 * @tc.expected: dragDropManager is not null.
1275 */
1276 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1277 ASSERT_NE(dragDropManager, nullptr);
1278
1279 /**
1280 * @tc.steps: step2. call AddDataToClipboard with extraInfo.
1281 * @tc.expected: extraInfo.empty() returns true value.
1282 */
1283 std::string extraInfo;
1284 dragDropManager->AddDataToClipboard(extraInfo);
1285 EXPECT_TRUE(extraInfo.empty());
1286 }
1287
1288 /**
1289 * @tc.name: DragDropManagerTest047
1290 * @tc.desc: Test OnDragMoveOut
1291 * @tc.type: FUNC
1292 * @tc.author:
1293 */
1294 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest047, TestSize.Level1)
1295 {
1296 /**
1297 * @tc.steps: step1. Create DragDropManager.
1298 * @tc.expected: dragDropManager is not null.
1299 */
1300 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1301 ASSERT_NE(dragDropManager, nullptr);
1302
1303 /**
1304 * @tc.steps: step2. call OnDragMoveOut with pointerEvent.
1305 * @tc.expected: container is null.
1306 */
1307 DragPointerEvent pointerEvent;
1308 dragDropManager->OnDragMoveOut(pointerEvent);
1309 auto container = Container::Current();
1310 ASSERT_NE(container, nullptr);
1311
1312 /**
1313 * @tc.steps: step3. construct a frameNode.
1314 * @tc.expected: frameNode is not null.
1315 */
1316 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
1317 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
1318 ASSERT_NE(frameNode, nullptr);
1319
1320 /**
1321 * @tc.steps: step4. call OnDragMoveOut with pointerEvent.
1322 * @tc.expected: dragDropManager->IsNeedScaleDragPreview() the return value is true.
1323 */
1324 dragDropManager->OnDragStart(Point(1.0f, 1.0f), frameNode);
1325 dragDropManager->info_.scale = 0.5f;
1326 dragDropManager->OnDragMoveOut(pointerEvent);
1327 EXPECT_TRUE(dragDropManager->IsNeedScaleDragPreview());
1328 }
1329
1330 /**
1331 * @tc.name: DragDropManagerTest048
1332 * @tc.desc: Test UpdateDragListener
1333 * @tc.type: FUNC
1334 * @tc.author:
1335 */
1336 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest048, TestSize.Level1)
1337 {
1338 /**
1339 * @tc.steps: step1. Create DragDropManager.
1340 * @tc.expected: dragDropManager is not null.
1341 */
1342 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1343 ASSERT_NE(dragDropManager, nullptr);
1344
1345 /**
1346 * @tc.steps: step2. construct frameNode and geometryNode and update the properties.
1347 * @tc.expected: frameNode and geometryNode are not null.
1348 */
1349 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
1350 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
1351 ASSERT_NE(frameNode, nullptr);
1352 auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
1353 ASSERT_NE(frameNode, nullptr);
1354
1355 geometryNode->SetFrameSize(FRAME_SIZE);
1356 frameNode->SetActive(true);
1357 frameNode->onMainTree_ = true;
1358 frameNode->SetGeometryNode(geometryNode);
1359 std::unordered_set<int32_t> frameNodeList;
1360 frameNodeList.emplace(frameNode->GetId());
1361 dragDropManager->parentHitNodes_ = std::move(frameNodeList);
1362 dragDropManager->RegisterDragStatusListener(frameNode->GetId(), AceType::WeakClaim(AceType::RawPtr(frameNode)));
1363
1364 /**
1365 * @tc.steps: step3. call UpdateDragListener with Point.
1366 * @tc.expected: dragDropManager->FindHitFrameNodes(point).empty() and
1367 * dragDropManager->nodesForDragNotify_.empty() return a false value
1368 */
1369 Point point(GLOBAL_X, GLOBAL_Y);
1370 dragDropManager->UpdateDragListener(point);
1371 EXPECT_FALSE(dragDropManager->FindHitFrameNodes(point).empty());
1372 EXPECT_FALSE(dragDropManager->nodesForDragNotify_.empty());
1373
1374 /**
1375 * @tc.steps: step4. call UpdateDragListener with Point.
1376 * @tc.expected: dragDropManager->FindHitFrameNodes(point).empty() return a true value.
1377 */
1378 dragDropManager->UnRegisterDragStatusListener(frameNode->GetId());
1379 frameNode->SetActive(false);
1380 dragDropManager->RegisterDragStatusListener(frameNode->GetId(), AceType::WeakClaim(AceType::RawPtr(frameNode)));
1381 dragDropManager->UpdateDragListener(point);
1382 EXPECT_TRUE(dragDropManager->FindHitFrameNodes(point).empty());
1383
1384 /**
1385 * @tc.steps: step5. call UpdateDragListener with Point.
1386 * @tc.expected: dragDropManager->FindHitFrameNodes(point).empty() return a true value.
1387 */
1388 dragDropManager->parentHitNodes_.clear();
1389 dragDropManager->UpdateDragListener(point);
1390 EXPECT_TRUE(dragDropManager->FindHitFrameNodes(point).empty());
1391
1392 /**
1393 * @tc.steps: step6. call UpdateDragListener with Point.
1394 * @tc.expected: dragDropManager->FindHitFrameNodes(point).empty() return a false value.
1395 */
1396 dragDropManager->UnRegisterDragStatusListener(frameNode->GetId());
1397 frameNode->SetActive(true);
1398 dragDropManager->RegisterDragStatusListener(frameNode->GetId(), AceType::WeakClaim(AceType::RawPtr(frameNode)));
1399 dragDropManager->UpdateDragListener(point);
1400 EXPECT_FALSE(dragDropManager->FindHitFrameNodes(point).empty());
1401 }
1402
1403 /**
1404 * @tc.name: DragDropManagerTest049
1405 * @tc.desc: Test UpdateDragAllowDrop
1406 * @tc.type: FUNC
1407 * @tc.author:
1408 */
1409 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest049, TestSize.Level1)
1410 {
1411 /**
1412 * @tc.steps: step1. create DragDropManager.
1413 * @tc.expected: dragDropManager is not null.
1414 */
1415 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1416 ASSERT_NE(dragDropManager, nullptr);
1417
1418 /**
1419 * @tc.steps: step2. construct frameNode and update the properties.
1420 * @tc.expected: frameNode is not null.
1421 */
1422 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
1423 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
1424 ASSERT_NE(frameNode, nullptr);
1425 std::set<std::string> allowDrop = { NODE_TAG };
1426 frameNode->SetAllowDrop(allowDrop);
1427
1428 /**
1429 * @tc.steps: step3. call UpdateDragAllowDrop with frameNode and copy.
1430 * @tc.expected: dragDropManager->summaryMap_.empty() return a true value.
1431 */
1432 dragDropManager->summaryMap_.clear();
1433 auto mockUdmfClient = static_cast<MockUdmfClient*>(UdmfClient::GetInstance());
1434 EXPECT_CALL(*mockUdmfClient, IsAppropriateType(_, _)).WillRepeatedly(testing::Return(true));
1435 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::COPY, -1);
1436 EXPECT_TRUE(dragDropManager->summaryMap_.empty());
1437
1438 /**
1439 * @tc.steps: step4. call UpdateDragAllowDrop with frameNode and copy.
1440 * @tc.expected: dragDropManager->summaryMap_.empty() return a false value.
1441 */
1442 dragDropManager->summaryMap_.insert(make_pair(NODE_TAG, frameNodeNullId));
1443 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::COPY, -1);
1444 EXPECT_FALSE(dragDropManager->summaryMap_.empty());
1445
1446 /**
1447 * @tc.steps: step5. call UpdateDragAllowDrop with frameNode and copy.
1448 * @tc.expected: allowDrop.find(ROOT_ETS_TAG) is equal to allowDrop.end().
1449 */
1450 dragDropManager->summaryMap_.clear();
1451 dragDropManager->summaryMap_.insert(make_pair(ROOT_ETS_TAG, frameNodeNullId));
1452 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::COPY, -1);
1453 EXPECT_TRUE(allowDrop.find(ROOT_ETS_TAG) == allowDrop.end());
1454 }
1455
1456 /**
1457 * @tc.name: DragDropManagerTest050
1458 * @tc.desc: Test FireOnDragEvent
1459 * @tc.type: FUNC
1460 * @tc.author:
1461 */
1462 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest050, TestSize.Level1)
1463 {
1464 /**
1465 * @tc.steps: step1. construct a DragDropManager.
1466 * @tc.expected: dragDropManager is not null.
1467 */
1468 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1469 ASSERT_NE(dragDropManager, nullptr);
1470
1471 /**
1472 * @tc.steps: step2. Construct frameNode and update the properties.
1473 * @tc.expected: frameNode and geometryNode are not null.
1474 */
1475 DragPointerEvent point;
1476 std::string extraInfo;
1477 dragDropManager->extraInfo_ = EXTRA_INFO;
1478 dragDropManager->isMouseDragged_ = true;
1479
1480 RefPtr<FrameNode> frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1481 ASSERT_NE(frameNode, nullptr);
1482 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
1483 std::string onDropInfo;
__anone0ed85120f02(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 1484 auto onDrop = [&onDropInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* info */) {
1485 onDropInfo = EXTRA_INFO;
1486 };
1487 eventHub->SetOnDrop(std::move(onDrop));
1488 EXPECT_TRUE(eventHub->HasOnDrop());
1489
1490 /**
1491 * @tc.steps: step3. call FireOnDragEvent.
1492 * @tc.expected: dragDropManager->isMouseDragged_ is true.
1493 */
1494 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::ENTER, extraInfo);
1495 EXPECT_TRUE(dragDropManager->isMouseDragged_);
1496
1497 /**
1498 * @tc.steps: step4. call FireOnDragEvent.
1499 * @tc.expected: !dragDropManager->isDragWindowShow_ is false.
1500 */
1501 dragDropManager->isDragWindowShow_ = true;
1502 dragDropManager->FireOnDragEvent(frameNode, point, DragEventType::ENTER, extraInfo);
1503 EXPECT_FALSE(!dragDropManager->isDragWindowShow_);
1504 }
1505
1506 /**
1507 * @tc.name: DragDropManagerTest051
1508 * @tc.desc: Test OnDragEnd
1509 * @tc.type: FUNC
1510 * @tc.author:
1511 */
1512 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest051, TestSize.Level1)
1513 {
1514 /**
1515 * @tc.steps: step1. construct a DragDropManager.
1516 * @tc.expected: dragDropManager is not null.
1517 */
1518 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1519 ASSERT_NE(dragDropManager, nullptr);
1520
1521 /**
1522 * @tc.steps: step2. call OnDragEnd with pointerEvent and extraInfo.
1523 * @tc.expected: dragDropManager->isDragCancel_ is true.
1524 */
1525 std::string extraInfo;
1526 DragPointerEvent pointerEvent;
1527 dragDropManager->SetIsDragCancel(true);
1528 dragDropManager->OnDragEnd(pointerEvent, extraInfo);
1529 EXPECT_TRUE(dragDropManager->isDragCancel_);
1530 }
1531
1532 /**
1533 * @tc.name: DragDropManagerTest053
1534 * @tc.desc: Test CalcDragPreviewDistanceWithPoint
1535 * @tc.type: FUNC
1536 * @tc.author:
1537 */
1538 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest053, TestSize.Level1)
1539 {
1540 /**
1541 * @tc.steps: step1. construct a DragDropManager.
1542 * @tc.expected: dragDropManager is not null.
1543 */
1544 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1545 ASSERT_NE(dragDropManager, nullptr);
1546
1547 /**
1548 * @tc.steps: step2. Construct frameNode and update the properties.
1549 * @tc.expected: frameNode is not null.
1550 */
1551 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
1552 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
1553 ASSERT_NE(frameNode, nullptr);
1554
1555 frameNode->GetTransformRelativeOffset();
1556 auto renderContext = frameNode->GetRenderContext();
1557 ASSERT_NE(renderContext, nullptr);
1558
1559 /**
1560 * @tc.steps: step3. call CalcDragPreviewDistanceWithPoint.
1561 * @tc.expected: pipeline is true.
1562 */
1563 Dimension preserverHeight;
1564 dragDropManager->CalcDragPreviewDistanceWithPoint(preserverHeight, GLOBAL_X, GLOBAL_Y, dragDropManager->info_);
1565 auto pipeline = PipelineContext::GetCurrentContext();
1566 EXPECT_TRUE(pipeline);
1567 }
1568 /**
1569 * @tc.name: DragDropManagerTest054
1570 * @tc.desc: Test DragEventStrictReportingEnabled
1571 * @tc.type: FUNC
1572 * @tc.author:
1573 */
1574 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest054, TestSize.Level1)
1575 {
1576 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1577 ASSERT_NE(dragDropManager, nullptr);
1578 bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1579 dragDropManager->SetEventStrictReportingEnabled(true);
1580 bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1581 dragDropManager->SetEventStrictReportingEnabled(false);
1582 bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1583 ASSERT_FALSE(reportingEnabledDefault);
1584 ASSERT_TRUE(reportingEnabledTrue);
1585 ASSERT_FALSE(reportingEnabledFalse);
1586 }
1587
1588 /**
1589 * @tc.name: DragDropManagerTest055
1590 * @tc.desc: Test AddDataToClipboard
1591 * @tc.type: FUNC
1592 * @tc.author:
1593 */
1594 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest055, TestSize.Level1)
1595 {
1596 /**
1597 * @tc.steps: step1. Create DragDropManager.
1598 * @tc.expected: dragDropManager is not null.
1599 */
1600 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1601 ASSERT_NE(dragDropManager, nullptr);
1602
1603 /**
1604 * @tc.steps: step2. call AddDataToClipboard with extraInfo.
1605 * @tc.expected: extraInfo.empty() returns true value.
1606 */
1607 std::string extraInfo;
1608 dragDropManager->AddDataToClipboard(extraInfo);
1609 EXPECT_TRUE(extraInfo.empty());
1610 }
1611
1612 /**
1613 * @tc.name: DragDropManagerTest056
1614 * @tc.desc: Test ClearExtraInfo
1615 * @tc.type: FUNC
1616 * @tc.author:
1617 */
1618 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest056, TestSize.Level1)
1619 {
1620 /**
1621 * @tc.steps: step1. construct a DragDropManager.
1622 */
1623 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1624
1625 /**
1626 * @tc.steps: step2. call OnDragStart
1627 */
1628 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1629 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
1630 auto draggedNode = dragDropManager->draggedFrameNode_;
1631
1632 /**
1633 * @tc.expected: draggedNode is true.
1634 */
1635 dragDropManager->ClearExtraInfo();
1636 EXPECT_TRUE(draggedNode);
1637 }
1638
1639 /**
1640 * @tc.name: DragDropManagerTest057
1641 * @tc.desc: Test SetExtraInfo
1642 * @tc.type: FUNC
1643 * @tc.author:
1644 */
1645 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest057, TestSize.Level1)
1646 {
1647 /**
1648 * @tc.steps: step1. construct a DragDropManager.
1649 */
1650 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1651
1652 /**
1653 * @tc.steps: step2. call OnDragStart
1654 */
1655 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1656 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
1657
1658 /**
1659 * @tc.expected: dragDropManager->GetExtraInfo() returns "ExtraInfo".
1660 */
1661 dragDropManager->SetExtraInfo("ExtraInfo");
1662 EXPECT_EQ(dragDropManager->GetExtraInfo(), "ExtraInfo");
1663 }
1664
1665 /**
1666 * @tc.name: DragDropManagerTest058
1667 * @tc.desc: Test GetItemIndex
1668 * @tc.type: FUNC
1669 * @tc.author:
1670 */
1671 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest058, TestSize.Level1)
1672 {
1673 /**
1674 * @tc.steps: step1. construct a DragDropManager.
1675 * @tc.expected: dragDropManager is not null.
1676 */
1677 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1678 ASSERT_NE(dragDropManager, nullptr);
1679
1680 /**
1681 * @tc.steps: step2. call OnDragStart
1682 * @tc.expected: FireOnItemDropEvent
1683 */
1684 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1685 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
1686 auto draggedNode = dragDropManager->draggedFrameNode_;
1687 auto preTargetNode = dragDropManager->preTargetFrameNode_;
1688
1689 /**
1690 * @tc.steps: step3. call OnItemDragEnd
1691 */
1692 dragDropManager->OnItemDragEnd(0.0, 0.0, 0, DragType::COMMON);
1693 ASSERT_TRUE(draggedNode);
1694 ASSERT_TRUE(preTargetNode);
1695 OHOS::Ace::ItemDragInfo itemDragInfo;
1696
1697 /**
1698 * @tc.steps: step4. call GetItemIndex
1699 * @tc.expected: draggedNode is true.
1700 */
1701 dragDropManager->GetItemIndex(frameNode, DragType::TEXT, 0.0, 0.0);
1702 ASSERT_TRUE(draggedNode);
1703 dragDropManager->GetItemIndex(frameNode, DragType::COMMON, 0.0, 0.0);
1704 ASSERT_TRUE(draggedNode);
1705 dragDropManager->GetItemIndex(frameNode, DragType::GRID, 0.0, 0.0);
1706 ASSERT_TRUE(draggedNode);
1707 dragDropManager->draggedGridFrameNode_ = frameNode;
1708 dragDropManager->GetItemIndex(frameNode, DragType::GRID, 0.0, 0.0);
1709 ASSERT_TRUE(draggedNode);
1710 }
1711
1712 /**
1713 * @tc.name: DragDropManagerTest059
1714 * @tc.desc: Test FireOnItemDropEvent
1715 * @tc.type: FUNC
1716 * @tc.author:
1717 */
1718 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest059, TestSize.Level1)
1719 {
1720 /**
1721 * @tc.steps: step1. construct a DragDropManager.
1722 * @tc.expected: dragDropManager is not null.
1723 */
1724 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1725 ASSERT_NE(dragDropManager, nullptr);
1726
1727 /**
1728 * @tc.steps: step2. call OnDragStart
1729 * @tc.expected: FireOnItemDropEvent
1730 */
1731 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1732 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
1733 auto draggedNode = dragDropManager->draggedFrameNode_;
1734 auto preTargetNode = dragDropManager->preTargetFrameNode_;
1735
1736 /**
1737 * @tc.steps: step3. call OnItemDragEnd
1738 */
1739 dragDropManager->OnItemDragEnd(0.0, 0.0, 0, DragType::COMMON);
1740 ASSERT_TRUE(draggedNode);
1741 ASSERT_TRUE(preTargetNode);
1742 OHOS::Ace::ItemDragInfo itemDragInfo;
1743
1744 /**
1745 * @tc.steps: step4. call FireOnItemDropEvent
1746 * @tc.expected: draggedNode and preTargetNode are true.
1747 */
1748 dragDropManager->FireOnItemDropEvent(frameNode, DragType::TEXT, itemDragInfo, 0, 0, true);
1749 ASSERT_TRUE(draggedNode);
1750 ASSERT_TRUE(preTargetNode);
1751 }
1752
1753 /**
1754 * @tc.name: DragDropManagerTest061
1755 * @tc.desc: Test DoDragMoveAnimate
1756 * @tc.type: FUNC
1757 * @tc.author:
1758 */
1759 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest061, TestSize.Level1)
1760 {
1761 /**
1762 * @tc.steps: step1. construct a DragDropManager.
1763 * @tc.expected: dragDropManager is not null.
1764 */
1765 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1766 ASSERT_NE(dragDropManager, nullptr);
1767
1768 /**
1769 * @tc.steps: step2. call DoDragMoveAnimate with pointerEvent.
1770 * @tc.expected: dragDropManager->IsNeedScaleDragPreview() returns true.
1771 */
1772 DragPointerEvent pointerEvent;
1773 dragDropManager->info_.scale = 0.5f;
1774 dragDropManager->DoDragMoveAnimate(pointerEvent);
1775 EXPECT_TRUE(dragDropManager->IsNeedScaleDragPreview());
1776
1777 auto subwindow = Subwindow::CreateSubwindow(VALID_CURRENT_ID);
1778 SubwindowManager::GetInstance()->AddSubwindow(VALID_CURRENT_ID, subwindow);
1779
1780 /**
1781 * @tc.steps: step3. call DoDragMoveAnimate with pointerEvent.
1782 * @tc.expected: overlayManager is null.
1783 */
1784 dragDropManager->DoDragMoveAnimate(pointerEvent);
1785 auto overlayManager = subwindow->GetOverlayManager();
1786 ASSERT_EQ(overlayManager, nullptr);
1787 }
1788
1789 /**
1790 * @tc.name: DragDropManagerTest062
1791 * @tc.desc: Test FireOnEditableTextComponent
1792 * @tc.type: FUNC
1793 * @tc.author:
1794 */
1795 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest062, TestSize.Level1)
1796 {
1797 /**
1798 * @tc.steps: step1. construct a DragDropManager and create a point.
1799 * @tc.expected: dragDropManager is not null.
1800 */
1801 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1802
1803 /**
1804 * @tc.steps: step2. Create a normal frameNode which is not a editable text component,
1805 * and test FireOnEditableTextComponent.
1806 * @tc.expected: step2.
1807 */
1808 {
1809 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1810 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::ENTER);
1811 }
1812
1813 /**
1814 * @tc.steps: step3. Create a editable text component, and test FireOnEditableTextComponent.
1815 * @tc.expected: step3.
1816 */
1817 {
1818 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXTINPUT_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
1819 #ifdef ENABLE_DRAG_FRAMEWORK
1820 EXPECT_CALL(*(AceType::DynamicCast<MockInteractionInterface>(MockInteractionInterface::GetInstance())),
1821 EnterTextEditorArea(_))
1822 .Times(1)
1823 .WillOnce(::testing::Return(0));
1824 #else
1825 EXPECT_CALL(*(AceType::DynamicCast<MockInteractionInterface>(MockInteractionInterface::GetInstance())),
1826 EnterTextEditorArea(_))
1827 .Times(1);
1828 #endif // ENABLE_DRAG_FRAMEWORK
1829 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::ENTER);
1830 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::ENTER);
1831 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::MOVE);
1832 dragDropManager->FireOnEditableTextComponent(frameNode, DragEventType::LEAVE);
1833 }
1834 }
1835 /**
1836 * @tc.name: DragDropManagerTest063
1837 * @tc.desc: Test FireOnItemDragEvent
1838 * @tc.type: FUNC
1839 * @tc.author:
1840 */
1841 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest063, TestSize.Level1)
1842 {
1843 /**
1844 * @tc.steps: step1. construct a DragDropManager
1845 */
1846 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1847 GestureEvent gestureEvent;
1848 auto dragDropProxy = dragDropManager->CreateFrameworkDragDropProxy();
1849 EXPECT_TRUE(dragDropProxy);
1850
1851 /**
1852 * @tc.steps: step2. construct a frameNode whose tag is List set its ItemDragEvent and GeometryNode
1853 */
1854 auto frameNode = AceType::MakeRefPtr<FrameNode>(LIST_TAG, -1, AceType::MakeRefPtr<ListPattern>());
1855 auto eventHub = frameNode->GetOrCreateEventHub<ListEventHub>();
1856
1857 // Set OnItemDragLeave callback
1858 std::string itemInfoLeave;
__anone0ed85121002(const ItemDragInfo& , int32_t ) 1859 auto onItemDragLeave = [&itemInfoLeave](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */) {
1860 itemInfoLeave = ITEM_INFO_LEAVE;
1861 };
1862 eventHub->SetOnItemDragLeave(std::move(onItemDragLeave));
1863
1864 // Set OnItemDragMove callback
1865 std::string itemInfoMove;
1866 auto onItemDragMove = [&itemInfoMove](const ItemDragInfo& /* dragInfo */, int32_t /* itemIndex */,
__anone0ed85121102(const ItemDragInfo& , int32_t , int32_t ) 1867 int32_t /* insertIndex */) { itemInfoMove = ITEM_INFO_MOVE; };
1868 eventHub->SetOnItemDragMove(std::move(onItemDragMove));
1869
1870 // Set OnItemDragEnter callback
1871 std::string itemInfoEnter;
__anone0ed85121202(const ItemDragInfo& ) 1872 auto onItemDragEnter = [&itemInfoEnter](const ItemDragInfo& /* dragInfo */) { itemInfoEnter = ITEM_INFO_ENTER; };
1873 eventHub->SetOnItemDragEnter(std::move(onItemDragEnter));
1874
1875 // Set geometry node to make sure (GLOBAL_X, GLOBAL_Y) in geoNode.frameRect_
1876 auto geoNode = AceType::MakeRefPtr<GeometryNode>();
1877 geoNode->SetMarginFrameOffset(FRAME_OFFSET);
1878 geoNode->SetFrameSize(FRAME_SIZE);
1879 frameNode->SetGeometryNode(geoNode);
1880
1881 /**
1882 * @tc.steps: step3. call OnItemDragMove
1883 * case: listDragFrameNodes_ is empty & preGridTargetFrameNode_ is not null
1884 * @tc.expected: step3. frameNode's onItemDragLeave_ will be called
1885 * itemInfoLeave will be assigned to ITEM_INFO_LEAVE
1886 */
1887 dragDropManager->OnItemDragStart(GLOBAL_X, GLOBAL_Y, frameNode);
1888 auto preGridTargetNode = dragDropManager->preGridTargetFrameNode_;
1889 dragDropManager->OnItemDragMove(GLOBAL_X, GLOBAL_Y, DRAGGED_INDEX, DRAG_TYPE_LIST);
1890 preGridTargetNode = dragDropManager->preGridTargetFrameNode_;
1891 dragDropManager->AddGridDragFrameNode(frameNode->GetId(), frameNode);
1892
1893 dragDropManager->OnItemDragStart(GLOBAL_X, GLOBAL_Y, frameNode);
1894 preGridTargetNode = dragDropManager->preGridTargetFrameNode_;
1895 dragDropManager->OnItemDragMove(GLOBAL_X, GLOBAL_Y, DRAGGED_INDEX, DRAG_TYPE_LIST);
1896 // to force call the FireOnItemDragEvent with DragType::LIST and DragEventType::MOVE
1897 OHOS::Ace::ItemDragInfo itemDragInfo;
1898 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::MOVE, DRAGGED_INDEX);
1899 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::ENTER, DRAGGED_INDEX);
1900 dragDropManager->FireOnItemDragEvent(frameNode, DragType::LIST, itemDragInfo, DragEventType::START, DRAGGED_INDEX);
1901 EXPECT_EQ(itemInfoMove, ITEM_INFO_MOVE);
1902 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::ENTER, DRAGGED_INDEX);
1903 EXPECT_EQ(itemInfoMove, ITEM_INFO_MOVE);
1904 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::MOVE, DRAGGED_INDEX);
1905 EXPECT_EQ(itemInfoMove, ITEM_INFO_MOVE);
1906 dragDropManager->FireOnItemDragEvent(frameNode, DragType::GRID, itemDragInfo, DragEventType::START, DRAGGED_INDEX);
1907 EXPECT_EQ(itemInfoMove, ITEM_INFO_MOVE);
1908 }
1909 /**
1910 * @tc.name: DragDropManagerTest064
1911 * @tc.desc: Test FindTargetInChildNodes with parentNode being nullptr
1912 * @tc.type: FUNC
1913 * @tc.author:
1914 */
1915 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest064, TestSize.Level1)
1916 {
1917 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1918 RefPtr<UINode> parentNode = nullptr;
1919 std::vector<RefPtr<FrameNode>> hitFrameNodes;
1920 bool findDrop = true;
1921 auto result = dragDropManager->FindTargetInChildNodes(parentNode, hitFrameNodes, findDrop);
1922 EXPECT_EQ(result, nullptr);
1923 }
1924 /**
1925 * @tc.name: DragDropManagerTest065
1926 * @tc.desc: Test FindTargetInChildNodes with matching hitFrameNode having no event hub
1927 * @tc.type: FUNC
1928 * @tc.author:
1929 */
1930 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest065, TestSize.Level1)
1931 {
1932 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1933 auto parentNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1934 std::vector<RefPtr<FrameNode>> hitFrameNodes = { parentNode };
1935 bool findDrop = true;
1936 auto result = dragDropManager->FindTargetInChildNodes(parentNode, hitFrameNodes, findDrop);
1937 EXPECT_EQ(result, nullptr);
1938 }
1939
1940 /**
1941 * @tc.name: DragDropManagerTest066
1942 * @tc.desc: Test FindDragFrameNodeByPosition and FindTargetDropNode
1943 * @tc.type: FUNC
1944 * @tc.author:
1945 */
1946 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest066, TestSize.Level1)
1947 {
1948 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1949 EXPECT_NE(dragDropManager, nullptr);
1950 auto pipeline = PipelineContext::GetCurrentContext();
1951 EXPECT_NE(pipeline, nullptr);
1952 auto rootNode = pipeline->GetRootElement();
1953 EXPECT_NE(rootNode, nullptr);
1954 auto parentFrameNode = AceType::DynamicCast<FrameNode>(rootNode);
1955 EXPECT_NE(parentFrameNode, nullptr);
1956 parentFrameNode->isActive_ = false;
1957 constexpr float GLOBAL_X = 10.0f;
1958 constexpr float GLOBAL_Y = 20.0f;
1959 auto targetDropNode = dragDropManager->FindDragFrameNodeByPosition(GLOBAL_X, GLOBAL_Y);
1960 EXPECT_TRUE(!parentFrameNode->IsActive());
1961 EXPECT_TRUE(parentFrameNode->IsVisible());
1962 EXPECT_EQ(targetDropNode, nullptr);
1963
1964 parentFrameNode->isActive_ = true;
1965 auto renderContext = parentFrameNode->GetRenderContext();
1966 EXPECT_NE(renderContext, nullptr);
1967 dragDropManager->FindDragFrameNodeByPosition(GLOBAL_X, GLOBAL_Y);
1968 EXPECT_FALSE(!parentFrameNode->IsActive());
1969 EXPECT_FALSE(!parentFrameNode->IsVisible());
1970 }
1971
1972 /**
1973 * @tc.name: DragDropManagerTest067
1974 * @tc.desc: Test UpdateDragAllowDrop
1975 * @tc.type: FUNC
1976 * @tc.author:
1977 */
1978 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest067, TestSize.Level1)
1979 {
1980 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1981 EXPECT_NE(dragDropManager, nullptr);
1982 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
1983 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
1984 ASSERT_NE(frameNode, nullptr);
1985 dragDropManager->summaryMap_.insert(make_pair(NODE_TAG, frameNodeNullId));
1986 std::set<std::string> allowDrop = { NODE_TAG };
1987 frameNode->SetAllowDrop(allowDrop);
1988 const auto& dragFrameNodeAllowDrop = frameNode->GetAllowDrop();
1989 EXPECT_NE(dragDropManager->draggedFrameNode_, frameNode);
1990 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::UNKNOWN, -1);
1991 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::MOVE, -1);
1992 EXPECT_FALSE(dragFrameNodeAllowDrop.empty());
1993 EXPECT_FALSE(dragDropManager->summaryMap_.empty());
1994
1995 dragDropManager->draggedFrameNode_ = frameNode;
1996 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::UNKNOWN, -1);
1997 EXPECT_EQ(dragDropManager->draggedFrameNode_, frameNode);
1998 }
1999
2000 /**
2001 * @tc.name: DragDropManagerTest068
2002 * @tc.desc: Test PrintDragFrameNode
2003 * @tc.type: FUNC
2004 * @tc.author:
2005 */
2006 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest068, TestSize.Level1)
2007 {
2008 /**
2009 * @tc.steps: step1. construct a DragDropManager
2010 */
2011 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2012 OHOS::Ace::DragPointerEvent point;
2013
2014 /**
2015 * @tc.steps: step2. Invoke PrintDragFrameNode
2016 * @tc.expected: dragDropManager->preTargetFrameNode_ is false
2017 */
2018 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2019 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
2020 auto draggedNode = dragDropManager->draggedFrameNode_;
2021 auto preTargetNode = dragDropManager->preTargetFrameNode_;
2022 dragDropManager->preTargetFrameNode_ = nullptr;
2023 dragDropManager->PrintDragFrameNode(point, frameNode);
2024 EXPECT_FALSE(dragDropManager->preTargetFrameNode_);
2025 }
2026
2027 /**
2028 * @tc.name: DragDropManagerTest069
2029 * @tc.desc: Test PrintGridDragFrameNode
2030 * @tc.type: FUNC
2031 * @tc.author:
2032 */
2033 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest069, TestSize.Level1)
2034 {
2035 /**
2036 * @tc.steps: step1. construct a DragDropManager
2037 */
2038 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2039
2040 /**
2041 * @tc.steps: step2. Invoke PrintGridDragFrameNode
2042 * @tc.expected: dragDropManager->preGridTargetFrameNode_ is false
2043 */
2044 auto frameNode1 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2045 ASSERT_NE(frameNode1, nullptr);
2046 dragDropManager->PrintGridDragFrameNode(GLOBAL_X, GLOBAL_Y, frameNode1);
2047 EXPECT_FALSE(dragDropManager->preGridTargetFrameNode_);
2048
2049 /**
2050 * @tc.steps: step3. Invoke PrintGridDragFrameNode
2051 * @tc.expected: dragDropManager->preGridTargetFrameNode_ is true
2052 */
2053 auto frameNode2 = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
2054 ASSERT_NE(frameNode2, nullptr);
2055 dragDropManager->preGridTargetFrameNode_ = frameNode2;
2056 dragDropManager->PrintGridDragFrameNode(GLOBAL_X, GLOBAL_Y, frameNode1);
2057 EXPECT_TRUE(dragDropManager->preGridTargetFrameNode_);
2058 }
2059
2060 /**
2061 * @tc.name: DragDropManagerTest070
2062 * @tc.desc: Test TransDragWindowToDragFwk
2063 * @tc.type: FUNC
2064 * @tc.author:
2065 */
2066 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest070, TestSize.Level1)
2067 {
2068 /**
2069 * @tc.steps: step1. construct a DragDropManager
2070 */
2071 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2072 auto containerId = Container::CurrentId();
2073
2074 /**
2075 * @tc.steps: step2. Invoke TransDragWindowToDragFwk
2076 * @tc.expected: dragDropManager->isDragFwkShow_ is true
2077 */
2078 dragDropManager->isDragFwkShow_ = true;
2079 dragDropManager->TransDragWindowToDragFwk(containerId);
2080 EXPECT_TRUE(dragDropManager->isDragFwkShow_);
2081 }
2082
2083 /**
2084 * @tc.name: DragDropManagerTest071
2085 * @tc.desc: Test ReachMoveLimit and isTimeLimited and isDistanceLimited
2086 * @tc.type: FUNC
2087 * @tc.author:
2088 */
2089 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest071, TestSize.Level1)
2090 {
2091 /**
2092 * @tc.steps: step1. construct a DragDropManager
2093 */
2094 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2095
2096 /**
2097 * @tc.steps: step2. Invoke ReachMoveLimit
2098 * @tc.expected: isTimeLimited returns false and isDistanceLimited returns true
2099 */
2100 DragPointerEvent pointerEvent;
2101 auto point = Point(1, 1);
2102 pointerEvent.sourceTool = SourceTool::MOUSE;
2103 auto moveLimit = dragDropManager->ReachMoveLimit(pointerEvent, point);
2104 EXPECT_FALSE(dragDropManager->isTimeLimited(pointerEvent, point));
2105 EXPECT_TRUE(dragDropManager->isDistanceLimited(point));
2106 EXPECT_FALSE(moveLimit);
2107
2108 /**
2109 * @tc.steps: step3. Invoke ReachMoveLimit
2110 * @tc.expected: isTimeLimited returns false and isDistanceLimited returns false
2111 */
2112 point = Point(100, 100);
2113 moveLimit = dragDropManager->ReachMoveLimit(pointerEvent, point);
2114 EXPECT_FALSE(dragDropManager->isTimeLimited(pointerEvent, point));
2115 EXPECT_FALSE(dragDropManager->isDistanceLimited(point));
2116 EXPECT_FALSE(moveLimit);
2117 }
2118
2119 /**
2120 * @tc.name: DragDropManagerTest072
2121 * @tc.desc: Test ReachMoveLimit and isTimeLimited and isDistanceLimited
2122 * @tc.type: FUNC
2123 * @tc.author:
2124 */
2125 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest072, TestSize.Level1)
2126 {
2127 /**
2128 * @tc.steps: step1. construct a DragDropManager
2129 */
2130 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2131
2132 /**
2133 * @tc.steps: step2. Invoke RequestDragSummaryInfoAndPrivilege
2134 */
2135 int ret = InteractionInterface::GetInstance()->AddPrivilege();
2136 dragDropManager->RequestDragSummaryInfoAndPrivilege();
2137 EXPECT_FALSE(ret != 0);
2138 EXPECT_FALSE(SystemProperties::GetDebugEnabled());
2139
2140 /**
2141 * @tc.steps: step3. Invoke RequestDragSummaryInfoAndPrivilege
2142 */
2143 SystemProperties::debugEnabled_ = true;
2144 dragDropManager->RequestDragSummaryInfoAndPrivilege();
2145 EXPECT_FALSE(ret != 0);
2146 EXPECT_TRUE(SystemProperties::GetDebugEnabled());
2147 }
2148
2149 /**
2150 * @tc.name: DragDropManagerTest073
2151 * @tc.desc: Test DoDropAction
2152 * @tc.type: FUNC
2153 * @tc.author:
2154 */
2155 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest073, TestSize.Level1)
2156 {
2157 /**
2158 * @tc.steps: step1. construct a DragDropManager
2159 */
2160 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2161
2162 /**
2163 * @tc.steps: step1. Invoke DoDropAction
2164 */
2165 DragPointerEvent pointerEvent;
2166 auto dragFrameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
2167 std::string udKey;
2168 InteractionInterface::GetInstance()->GetUdKey(udKey);
2169 auto unifiedData = dragDropManager->RequestUDMFDataWithUDKey(udKey);
2170 dragDropManager->DoDropAction(dragFrameNode, pointerEvent, unifiedData, udKey);
2171 EXPECT_FALSE(!udKey.empty());
2172 }
2173
2174 /**
2175 * @tc.name: DragDropManagerTest074
2176 * @tc.desc: Test DoDropAction
2177 * @tc.type: FUNC
2178 * @tc.author:
2179 */
2180 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest074, TestSize.Level1)
2181 {
2182 /**
2183 * @tc.steps: step1. construct a DragDropManager
2184 */
2185 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2186
2187 /**
2188 * @tc.steps: step1. Invoke DoDropAction
2189 */
2190 DragPointerEvent pointerEvent;
2191 auto dragFrameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
2192 std::string udKey;
2193 InteractionInterface::GetInstance()->GetUdKey(udKey);
2194 auto unifiedData = dragDropManager->RequestUDMFDataWithUDKey(udKey);
2195 dragDropManager->DoDropAction(dragFrameNode, pointerEvent, unifiedData, udKey);
2196 EXPECT_FALSE(!udKey.empty());
2197 }
2198
2199 /**
2200 * @tc.name: DragDropManagerTest075
2201 * @tc.desc: Test FindTargetDropNode with scale
2202 * @tc.type: FUNC
2203 * @tc.author:
2204 */
2205 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest075, TestSize.Level1)
2206 {
2207 /**
2208 * @tc.steps: step1. construct a DragDropManager
2209 */
2210 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2211 ASSERT_NE(dragDropManager, nullptr);
2212
2213 /**
2214 * @tc.steps: step2. construct a frameNode
2215 */
2216 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2217 ASSERT_NE(frameNode, nullptr);
2218 auto renderContext = AceType::MakeRefPtr<MockRenderContext>();
2219 frameNode->renderContext_ = renderContext;
2220 ASSERT_NE(renderContext, nullptr);
2221 renderContext->paintRect_ = RectF(0.0f, 0.0f, 15.0f, 15.0f);
2222 frameNode->isActive_ = true;
2223 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
2224 std::string onDropInfo;
__anone0ed85121302(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& ) 2225 auto onDrop = [&onDropInfo](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* info */) {
2226 onDropInfo = EXTRA_INFO;
2227 };
2228 eventHub->SetOnDrop(std::move(onDrop));
2229
2230 /**
2231 * @tc.steps: step3. call FindTargetDropNode
2232 */
2233 constexpr float GLOBAL_X = 10.0f;
2234 constexpr float GLOBAL_Y = 20.0f;
2235 PointF point = { GLOBAL_X, GLOBAL_Y };
2236 auto targetDropNode = dragDropManager->FindTargetDropNode(frameNode, point);
2237 EXPECT_EQ(targetDropNode, nullptr);
2238
2239 /**
2240 * @tc.steps: step4. set frameNode scale
2241 */
2242 frameNode->cacheMatrixInfo_.revertMatrix = Matrix4::CreateIdentity();
2243 constexpr float GLOBAL_SCALE = 0.5f;
2244 frameNode->cacheMatrixInfo_.revertMatrix.SetScale(GLOBAL_SCALE, GLOBAL_SCALE, 1.0f);
2245 targetDropNode = dragDropManager->FindTargetDropNode(frameNode, point);
2246 EXPECT_EQ(targetDropNode, frameNode);
2247 }
2248
2249 /**
2250 * @tc.name: DragDropManagerTest076
2251 * @tc.desc: Test GetScaleInfo with scale
2252 * @tc.type: FUNC
2253 * @tc.author:
2254 */
2255 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest076, TestSize.Level1)
2256 {
2257 constexpr float WIDTH_UNKOWN = 00.0f;
2258 constexpr float HEIGHT_UNKOWN = 00.0f;
2259 auto scaleUnkown = DragDropManager::GetScaleInfo(WIDTH_UNKOWN, HEIGHT_UNKOWN, true);
2260 ASSERT_NE(scaleUnkown, nullptr);
2261 EXPECT_FALSE(scaleUnkown->isNeedScale);
2262 constexpr float WIDTH_SMALL = 1.0f;
2263 constexpr float HEIGHT_SMALL = 1.0f;
2264 auto scaleSmall = DragDropManager::GetScaleInfo(WIDTH_SMALL, HEIGHT_SMALL, true);
2265 ASSERT_NE(scaleSmall, nullptr);
2266 EXPECT_EQ(scaleSmall->scale, 1);
2267 constexpr float WIDTH_LARGE = 2000.0f;
2268 constexpr float HEIGHT_LARGE = 2000.0f;
2269 auto scaleLarge = DragDropManager::GetScaleInfo(WIDTH_LARGE, HEIGHT_LARGE, false);
2270 ASSERT_NE(scaleLarge, nullptr);
2271 EXPECT_NE(scaleLarge->scale, 1);
2272 }
2273
2274 /**
2275 * @tc.name: IsAnyDraggableHit001
2276 * @tc.desc: Test IsAnyDraggableHit Funcition When isAnyDraggableHit_ Is False
2277 * @tc.type: FUNC
2278 * @tc.author:
2279 */
2280 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest077, TestSize.Level1)
2281 {
2282 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2283 ASSERT_NE(dragDropManager, nullptr);
2284 auto pipelineContext = MockPipelineContext::GetCurrentContext();
2285 ASSERT_NE(pipelineContext, nullptr);
2286 dragDropManager->SetIsAnyDraggableHit(false);
2287 bool result = dragDropManager->IsAnyDraggableHit(pipelineContext, 0);
2288 EXPECT_FALSE(result);
2289 }
2290
2291 /**
2292 * @tc.name: IsAnyDraggableHit002
2293 * @tc.desc: Test IsAnyDraggableHit Funcition When isAnyDraggableHit_ is True
2294 * @tc.type: FUNC
2295 * @tc.author:
2296 */
2297 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest078, TestSize.Level1)
2298 {
2299 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2300 ASSERT_NE(dragDropManager, nullptr);
2301 auto pipelineContext = MockPipelineContext::GetCurrentContext();
2302 ASSERT_NE(pipelineContext, nullptr);
2303 dragDropManager->SetIsAnyDraggableHit(true);
2304 bool result = dragDropManager->IsAnyDraggableHit(pipelineContext, 0);
2305 EXPECT_TRUE(result);
2306 }
2307
2308 /**
2309 * @tc.name: IsAnyDraggableHit003
2310 * @tc.desc: Test IsAnyDraggableHit Funcition When iter == touchTestResults.end() Is False AND iter->second.empty() Is
2311 * Fasle
2312 * @tc.type: FUNC
2313 * @tc.author:
2314 */
2315 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest079, TestSize.Level1)
2316 {
2317 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2318 ASSERT_NE(dragDropManager, nullptr);
2319 auto pipelineContext = MockPipelineContext::GetCurrentContext();
2320 ASSERT_NE(pipelineContext, nullptr);
2321 auto eventManager = pipelineContext->GetEventManager();
2322 ASSERT_NE(eventManager, nullptr);
2323 TouchTestResult hitTestResult;
2324 hitTestResult.emplace_back(AceType::MakeRefPtr<OHOS::Ace::NG::Scrollable>());
2325 eventManager->touchTestResults_[0] = hitTestResult;
2326 bool result = dragDropManager->IsAnyDraggableHit(pipelineContext, 0);
2327 EXPECT_FALSE(result);
2328 }
2329
2330 /**
2331 * @tc.name: IsAnyDraggableHit004
2332 * @tc.desc: Test IsAnyDraggableHit Funcition When iter == touchTestResults.end() Is False AND iter->second.empty() Is
2333 * True
2334 * @tc.type: FUNC
2335 * @tc.author:
2336 */
2337 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest080, TestSize.Level1)
2338 {
2339 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2340 ASSERT_NE(dragDropManager, nullptr);
2341 auto pipelineContext = MockPipelineContext::GetCurrentContext();
2342 ASSERT_NE(pipelineContext, nullptr);
2343 auto eventManager = pipelineContext->GetEventManager();
2344 ASSERT_NE(eventManager, nullptr);
2345 TouchTestResult hitTestResult;
2346 eventManager->touchTestResults_[0] = hitTestResult;
2347 bool result = dragDropManager->IsAnyDraggableHit(pipelineContext, 0);
2348 EXPECT_FALSE(result);
2349 }
2350
2351 /**
2352 * @tc.name: IsAnyDraggableHit005
2353 * @tc.desc: Test IsAnyDraggableHit Funcition When iter == touchTestResults.end() Is True AND iter->second.empty() Is
2354 * True
2355 * @tc.type: FUNC
2356 * @tc.author:
2357 */
2358 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest081, TestSize.Level1)
2359 {
2360 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2361 ASSERT_NE(dragDropManager, nullptr);
2362 auto pipelineContext = MockPipelineContext::GetCurrentContext();
2363 ASSERT_NE(pipelineContext, nullptr);
2364 auto eventManager = pipelineContext->GetEventManager();
2365 ASSERT_NE(eventManager, nullptr);
2366 bool result = dragDropManager->IsAnyDraggableHit(pipelineContext, -1);
2367 EXPECT_FALSE(result);
2368 }
2369
2370 /**
2371 * @tc.name: IsAnyDraggableHit006
2372 * @tc.desc: Test IsAnyDraggableHit Funcition When recognizer Is Not NULL
2373 * @tc.type: FUNC
2374 * @tc.author:
2375 */
2376 HWTEST_F(DragDropManagerTestNgNew, DragDropManagerTest082, TestSize.Level1)
2377 {
2378 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2379 ASSERT_NE(dragDropManager, nullptr);
2380 auto pipelineContext = MockPipelineContext::GetCurrentContext();
2381 ASSERT_NE(pipelineContext, nullptr);
2382 auto eventManager = pipelineContext->GetEventManager();
2383 ASSERT_NE(eventManager, nullptr);
2384 TouchTestResult hitTestResult;
2385 hitTestResult.emplace_back(AceType::MakeRefPtr<OHOS::Ace::NG::Scrollable>());
2386 eventManager->touchTestResults_[0] = hitTestResult;
2387 bool result = dragDropManager->IsAnyDraggableHit(pipelineContext, 0);
2388 EXPECT_FALSE(result);
2389 }
2390 } // namespace OHOS::Ace::NG