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