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