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