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/mock/core/common/mock_udmf.h"
16 #include "test/unittest/core/manager/drag_drop_manager_test_ng.h"
17
18 #include "core/common/udmf/udmf_client.h"
19 #include "core/common/udmf/unified_data.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23 namespace OHOS::Ace::NG {
SetUpTestCase()24 void DragDropManagerTestNgCoverage::SetUpTestCase()
25 {
26 MockPipelineContext::SetUp();
27 MockContainer::SetUp();
28 }
29
TearDownTestCase()30 void DragDropManagerTestNgCoverage::TearDownTestCase()
31 {
32 MockPipelineContext::TearDown();
33 MockContainer::TearDown();
34 }
35
36 /**
37 * @tc.name: DragDropManagerTestNgCoverage001
38 * @tc.desc: Test FindTargetInChildNodes
39 * @tc.type: FUNC
40 * @tc.author:
41 */
42 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage001, TestSize.Level1)
43 {
44 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
45 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
46 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>("parent", frameNodeNullId, AceType::MakeRefPtr<Pattern>());
47 frameNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
48 frameNodeNull->SetActive(true);
49 auto eventHub = frameNodeNull->GetEventHub<EventHub>();
50 CHECK_NULL_VOID(eventHub);
__anonbc09b1640102(const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) 51 auto onDragDrop = [](const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) {};
52 eventHub->SetOnDrop(std::move(onDragDrop));
53 auto childNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
54 auto childNodeNull = AceType::MakeRefPtr<FrameNode>(
55 V2::UI_EXTENSION_COMPONENT_ETS_TAG, childNodeNullId, AceType::MakeRefPtr<Pattern>());
56 childNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
57 childNodeNull->SetActive(true);
58 auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
59 geometryNode->SetFrameSize(FRAME_SIZE);
60 frameNodeNull->SetGeometryNode(geometryNode);
61 childNodeNull->SetGeometryNode(geometryNode);
62 auto pipelineTmp = NG::PipelineContext::GetCurrentContext();
63 auto parentNodeTmp = pipelineTmp->GetRootElement();
64 auto parentFrameNodeTmp = AceType::DynamicCast<FrameNode>(parentNodeTmp);
65 parentFrameNodeTmp->SetGeometryNode(geometryNode);
66 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(frameNodeNull));
67 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(childNodeNull));
68 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(nullptr));
69 dragDropManager->AddGridDragFrameNode(parentFrameNodeTmp->GetId(), parentFrameNodeTmp);
70 dragDropManager->AddGridDragFrameNode(frameNodeNull->GetId(), frameNodeNull);
71 dragDropManager->AddGridDragFrameNode(childNodeNull->GetId(), childNodeNull);
72 std::map<int32_t, WeakPtr<FrameNode>> frameNodes = dragDropManager->gridDragFrameNodes_;
73 PointF point(GLOBAL_X, GLOBAL_Y);
74 std::vector<RefPtr<FrameNode>> hitFrameNodes;
75 hitFrameNodes.push_back(parentFrameNodeTmp);
76 hitFrameNodes.push_back(frameNodeNull);
77 hitFrameNodes.push_back(childNodeNull);
78 auto pipeline = NG::PipelineContext::GetCurrentContext();
79 auto manager = pipeline->GetOverlayManager();
80 auto parentNode = pipeline->GetRootElement();
81 auto parentFrameNode = AceType::DynamicCast<FrameNode>(parentNode);
82 auto children = parentFrameNode->GetFrameChildren();
83 auto result = dragDropManager->FindTargetInChildNodes(parentNode, hitFrameNodes, true);
84 EXPECT_TRUE(result);
85 }
86
87 /**
88 * @tc.name: DragDropManagerTestNgCoverage002
89 * @tc.desc: Test FindTargetInChildNodes
90 * @tc.type: FUNC
91 * @tc.author:
92 */
93 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage002, TestSize.Level1)
94 {
95 /**
96 * @tc.steps: step1. creat node and generate a node tree.
97 */
98 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
99 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>());
100 const RefPtr<FrameNode> GET_CHILD1 = FrameNode::CreateFrameNode("child1", 5, AceType::MakeRefPtr<Pattern>());
101 const RefPtr<FrameNode> GET_CHILD2 = FrameNode::CreateFrameNode("child2", 6, AceType::MakeRefPtr<Pattern>());
102 GET_CHILD1->UpdateInspectorId("child1");
103 GET_CHILD2->UpdateInspectorId("child2");
104 GET_PARENT->frameChildren_.insert(GET_CHILD1);
105 GET_PARENT->frameChildren_.insert(GET_CHILD2);
106 std::vector<RefPtr<FrameNode>> hitFrameNodes;
107 hitFrameNodes.push_back(GET_PARENT);
108 hitFrameNodes.push_back(GET_CHILD1);
109 hitFrameNodes.push_back(GET_CHILD2);
110 dragDropManager->AddGridDragFrameNode(GET_PARENT->GetId(), GET_PARENT);
111
112 /**
113 * @tc.steps: step2. initialize parentEventHub and set HitTestMode.
114 */
115 auto parentEventHub = GET_PARENT->GetOrCreateGestureEventHub();
116 parentEventHub->SetHitTestMode(HitTestMode::HTMBLOCK);
117 auto dragResult = dragDropManager->FindTargetInChildNodes(GET_PARENT, hitFrameNodes, true);
118
119 /**
120 * @tc.steps: step3. call GetDispatchFrameNode.
121 * @tc.expected: expect GetDispatchFrameNode ruturn nullptr.
122 */
123 EXPECT_EQ(dragResult, nullptr);
124 }
125
126 /**
127 * @tc.name: DragDropManagerTestNgCoverage003
128 * @tc.desc: Test FindTargetInChildNodes with null child nodes
129 * @tc.type: FUNC
130 * @tc.author:
131 */
132 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage003, TestSize.Level1)
133 {
134 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
135 auto parentNode = AceType::MakeRefPtr<FrameNode>(
136 NODE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<GridPattern>());
137 for (int i = 0; i < 5; ++i) {
138 parentNode->frameChildren_.insert(WeakPtr<NG::FrameNode>(nullptr));
139 }
140 std::vector<RefPtr<FrameNode>> hitFrameNodes;
141 hitFrameNodes.push_back(parentNode);
142 auto result = dragDropManager->FindTargetInChildNodes(parentNode, hitFrameNodes, true);
143 EXPECT_EQ(result, nullptr);
144 }
145
146 /**
147 * @tc.name: DragDropManagerTestNgCoverage004
148 * @tc.desc: Test FindTargetInChildNodes with hit FrameNode having OnDrop event
149 * @tc.type: FUNC
150 * @tc.author:
151 */
152 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage004, TestSize.Level1)
153 {
154 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
155 auto parentNode = AceType::MakeRefPtr<FrameNode>(
156 NODE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<GridPattern>());
157 auto hitFrameNode = AceType::MakeRefPtr<FrameNode>(
158 NODE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<GridPattern>());
159 auto eventHub = AceType::MakeRefPtr<EventHub>();
160 auto parentEventHub = hitFrameNode->GetOrCreateGestureEventHub();
161 parentEventHub->SetHitTestMode(HitTestMode::HTMBLOCK);
162 dragDropManager->AddGridDragFrameNode(hitFrameNode->GetId(), hitFrameNode);
163
164 parentNode->frameChildren_.insert(WeakPtr<NG::FrameNode>(hitFrameNode));
165 std::vector<RefPtr<FrameNode>> hitFrameNodes;
166 hitFrameNodes.push_back(hitFrameNode);
167
168 auto result = dragDropManager->FindTargetInChildNodes(parentNode, hitFrameNodes, true);
169 EXPECT_FALSE(result);
170 }
171
172 /**
173 * @tc.name: DragDropManagerTestNgCoverage005
174 * @tc.desc: Test FindTargetDropNode with null parentNode
175 * @tc.type: FUNC
176 * @tc.author:
177 */
178 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage005, TestSize.Level1)
179 {
180 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
181 PointF point(0.0, 0.0);
182 auto result = dragDropManager->FindTargetDropNode(nullptr, point);
183 EXPECT_EQ(result, nullptr);
184 }
185
186 /**
187 * @tc.name: DragDropManagerTestNgCoverage006
188 * @tc.desc: Test FindTargetInChildNodes
189 * @tc.type: FUNC
190 * @tc.author:
191 */
192 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage006, TestSize.Level1)
193 {
194 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
195 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
196 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>("parent", frameNodeNullId, AceType::MakeRefPtr<Pattern>());
197 frameNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
198 frameNodeNull->SetActive(true);
199 auto eventHub = frameNodeNull->GetEventHub<EventHub>();
200 CHECK_NULL_VOID(eventHub);
__anonbc09b1640202(const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) 201 auto onDragDrop = [](const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) {};
202 eventHub->SetOnDrop(std::move(onDragDrop));
203 auto childNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
204 auto childNodeNull =
205 AceType::MakeRefPtr<FrameNode>(V2::EMBEDDED_COMPONENT_ETS_TAG, childNodeNullId, AceType::MakeRefPtr<Pattern>());
206 childNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
207 childNodeNull->SetActive(true);
208 auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
209 geometryNode->SetFrameSize(FRAME_SIZE);
210 frameNodeNull->SetGeometryNode(geometryNode);
211 childNodeNull->SetGeometryNode(geometryNode);
212 auto pipelineTmp = NG::PipelineContext::GetCurrentContext();
213 auto parentNodeTmp = pipelineTmp->GetRootElement();
214 auto parentFrameNodeTmp = AceType::DynamicCast<FrameNode>(parentNodeTmp);
215 parentFrameNodeTmp->SetGeometryNode(geometryNode);
216 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(frameNodeNull));
217 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(childNodeNull));
218 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(nullptr));
219 dragDropManager->AddGridDragFrameNode(parentFrameNodeTmp->GetId(), parentFrameNodeTmp);
220 dragDropManager->AddGridDragFrameNode(frameNodeNull->GetId(), frameNodeNull);
221 dragDropManager->AddGridDragFrameNode(childNodeNull->GetId(), childNodeNull);
222 std::map<int32_t, WeakPtr<FrameNode>> frameNodes = dragDropManager->gridDragFrameNodes_;
223 PointF point(GLOBAL_X, GLOBAL_Y);
224 std::vector<RefPtr<FrameNode>> hitFrameNodes;
225 hitFrameNodes.push_back(parentFrameNodeTmp);
226 hitFrameNodes.push_back(frameNodeNull);
227 hitFrameNodes.push_back(childNodeNull);
228 auto pipeline = NG::PipelineContext::GetCurrentContext();
229 auto manager = pipeline->GetOverlayManager();
230 auto parentNode = pipeline->GetRootElement();
231 auto parentFrameNode = AceType::DynamicCast<FrameNode>(parentNode);
232 auto children = parentFrameNode->GetFrameChildren();
233 auto result = dragDropManager->FindTargetInChildNodes(parentNode, hitFrameNodes, true);
234 EXPECT_TRUE(result);
235 }
236
237 /**
238 * @tc.name: DragDropManagerTestNgCoverage007
239 * @tc.desc: Test FindTargetDropNode with inactive or invisible parentFrameNode
240 * @tc.type: FUNC
241 * @tc.author:
242 */
243 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage007, TestSize.Level1)
244 {
245 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
246 auto parentNode = AceType::MakeRefPtr<FrameNode>(
247 NODE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<GridPattern>());
248 PointF point(0.0, 0.0);
249
250 parentNode->SetActive(false);
251 auto result = dragDropManager->FindTargetDropNode(parentNode, point);
252 EXPECT_EQ(result, nullptr);
253
254 parentNode->SetActive(true);
255 parentNode->GetLayoutProperty()->UpdateVisibility(VisibleType::INVISIBLE);
256 result = dragDropManager->FindTargetDropNode(parentNode, point);
257 EXPECT_EQ(result, nullptr);
258 }
259
260 /**
261 * @tc.name: DragDropManagerTestNgCoverage009
262 * @tc.desc: Test FindTargetDropNode with null child nodes
263 * @tc.type: FUNC
264 * @tc.author:
265 */
266 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage009, TestSize.Level1)
267 {
268 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
269 auto parentNode = AceType::MakeRefPtr<FrameNode>(
270 NODE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<GridPattern>());
271 for (int i = 0; i < 5; ++i) {
272 parentNode->frameChildren_.insert(WeakPtr<NG::FrameNode>(nullptr));
273 }
274 PointF point(0.0, 0.0);
275 auto result = dragDropManager->FindTargetDropNode(parentNode, point);
276 EXPECT_EQ(result, nullptr);
277 }
278
279 /**
280 * @tc.name: DragDropManagerTestNgCoverage010
281 * @tc.desc: Test FindTargetDropNode with null child nodes
282 * @tc.type: FUNC
283 * @tc.author:
284 */
285 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage010, TestSize.Level1)
286 {
287 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
288 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
289 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>("parent", frameNodeNullId, AceType::MakeRefPtr<Pattern>());
290 frameNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
291 frameNodeNull->SetActive(true);
292 auto eventHub = frameNodeNull->GetEventHub<EventHub>();
293 CHECK_NULL_VOID(eventHub);
__anonbc09b1640302(const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) 294 auto onDragDrop = [](const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) {};
295 eventHub->SetOnDrop(std::move(onDragDrop));
296 auto childNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
297 auto childNodeNull =
298 AceType::MakeRefPtr<FrameNode>(V2::EMBEDDED_COMPONENT_ETS_TAG, childNodeNullId, AceType::MakeRefPtr<Pattern>());
299 childNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
300 childNodeNull->SetActive(true);
301 auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
302 geometryNode->SetFrameSize(FRAME_SIZE);
303 frameNodeNull->SetGeometryNode(geometryNode);
304 childNodeNull->SetGeometryNode(geometryNode);
305 frameNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
306 childNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
307 auto pipelineTmp = NG::PipelineContext::GetCurrentContext();
308 auto parentNodeTmp = pipelineTmp->GetRootElement();
309 auto parentFrameNodeTmp = AceType::DynamicCast<FrameNode>(parentNodeTmp);
310 parentFrameNodeTmp->SetGeometryNode(geometryNode);
311 parentFrameNodeTmp->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
312 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(frameNodeNull));
313 frameNodeNull->frameChildren_.insert(WeakPtr<NG::FrameNode>(childNodeNull));
314 frameNodeNull->frameChildren_.insert(WeakPtr<NG::FrameNode>(nullptr));
315 dragDropManager->AddGridDragFrameNode(parentFrameNodeTmp->GetId(), parentFrameNodeTmp);
316 dragDropManager->AddGridDragFrameNode(frameNodeNull->GetId(), frameNodeNull);
317 dragDropManager->AddGridDragFrameNode(childNodeNull->GetId(), childNodeNull);
318 std::map<int32_t, WeakPtr<FrameNode>> frameNodes = dragDropManager->gridDragFrameNodes_;
319 PointF point(100.0, 100.0);
320 auto pipeline = NG::PipelineContext::GetCurrentContext();
321 auto manager = pipeline->GetOverlayManager();
322 auto parentNode = pipeline->GetRootElement();
323 auto parentFrameNode = AceType::DynamicCast<FrameNode>(parentNode);
324 auto children = parentFrameNode->GetFrameChildren();
325 auto result = dragDropManager->FindTargetDropNode(parentNode, point);
326 EXPECT_TRUE(result);
327 }
328
329 /**
330 * @tc.name: DragDropManagerTestNgCoverage011
331 * @tc.desc: Test UpdateDragAllowDrop
332 * @tc.type: FUNC
333 * @tc.author:
334 */
335 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage011, TestSize.Level1)
336 {
337 /**
338 * @tc.steps: step1. create DragDropManager.
339 * @tc.expected: dragDropManager is not null.
340 */
341 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
342 ASSERT_NE(dragDropManager, nullptr);
343
344 /**
345 * @tc.steps: step2. construct frameNode and update the properties.
346 * @tc.expected: frameNode is not null.
347 */
348 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
349 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
350 ASSERT_NE(frameNode, nullptr);
351 std::set<std::string> allowDrop = { NODE_TAG };
352 frameNode->SetAllowDrop(allowDrop);
353
354 /**
355 * @tc.steps: step2. construct frameNode and update the properties.
356 * @tc.expected: frameNode is not null.
357 */
358 auto childNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
359 auto childNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, childNodeNullId, AceType::MakeRefPtr<Pattern>());
360 ASSERT_NE(childNode, nullptr);
361 childNode->SetAllowDrop(allowDrop);
362
363 /**
364 * @tc.steps: step3. call UpdateDragAllowDrop with frameNode and copy.
365 * @tc.expected: dragDropManager->summaryMap_.empty() return a true value.
366 */
367 dragDropManager->summaryMap_.clear();
368 PointF point(100.0, 100.0);
369 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, childNode);
370 dragDropManager->summaryMap_.insert(make_pair(NODE_TAG, frameNodeNullId));
371 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::UNKNOWN, -1);
372 EXPECT_FALSE(dragDropManager->summaryMap_.empty());
373
374 /**
375 * @tc.steps: step3. call UpdateDragAllowDrop with frameNode and copy.
376 * @tc.expected: dragDropManager->summaryMap_.empty() return a true value.
377 */
378 dragDropManager->summaryMap_.clear();
379 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
380 dragDropManager->summaryMap_.insert(make_pair(NODE_TAG, frameNodeNullId));
381 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::UNKNOWN, -1);
382 EXPECT_FALSE(dragDropManager->summaryMap_.empty());
383
384 /**
385 * @tc.steps: step4. call UpdateDragAllowDrop with frameNode and copy.
386 * @tc.expected: dragDropManager->summaryMap_.empty() return a false value.
387 */
388 dragDropManager->summaryMap_.clear();
389 dragDropManager->summaryMap_.insert(make_pair(NODE_TAG, frameNodeNullId));
390 dragDropManager->UpdateDragAllowDrop(frameNode, DragBehavior::MOVE, -1);
391 EXPECT_FALSE(dragDropManager->summaryMap_.empty());
392
393 /**
394 * @tc.steps: step5. call UpdateDragAllowDrop with frameNode and copy.
395 * @tc.expected: allowDrop.find(ROOT_ETS_TAG) is equal to allowDrop.end().
396 */
397 dragDropManager->summaryMap_.clear();
398 dragDropManager->summaryMap_.insert(make_pair(ROOT_ETS_TAG, frameNodeNullId));
399 dragDropManager->UpdateDragAllowDrop(frameNode, static_cast<DragBehavior>(-100), -1);
400 EXPECT_TRUE(allowDrop.find(ROOT_ETS_TAG) == allowDrop.end());
401 }
402
403 /**
404 * @tc.name: DragDropManagerTestNgCoverage012
405 * @tc.desc: Test FindTargetDropNode with null child nodes
406 * @tc.type: FUNC
407 * @tc.author:
408 */
409 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage012, TestSize.Level1)
410 {
411 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
412 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
413 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>("parent", frameNodeNullId, AceType::MakeRefPtr<Pattern>());
414 frameNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
415 frameNodeNull->SetActive(true);
416 auto eventHub = frameNodeNull->GetEventHub<EventHub>();
417 CHECK_NULL_VOID(eventHub);
__anonbc09b1640402(const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) 418 auto onDragDrop = [](const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) {};
419 eventHub->SetOnDrop(std::move(onDragDrop));
420 auto childNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
421 auto childNodeNull = AceType::MakeRefPtr<FrameNode>(
422 V2::UI_EXTENSION_COMPONENT_ETS_TAG, childNodeNullId, AceType::MakeRefPtr<Pattern>());
423 childNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
424 childNodeNull->SetActive(true);
425 auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
426 geometryNode->SetFrameSize(FRAME_SIZE);
427 frameNodeNull->SetGeometryNode(geometryNode);
428 childNodeNull->SetGeometryNode(geometryNode);
429 frameNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
430 childNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
431 auto pipelineTmp = NG::PipelineContext::GetCurrentContext();
432 auto parentNodeTmp = pipelineTmp->GetRootElement();
433 auto parentFrameNodeTmp = AceType::DynamicCast<FrameNode>(parentNodeTmp);
434 parentFrameNodeTmp->SetGeometryNode(geometryNode);
435 parentFrameNodeTmp->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
436 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(frameNodeNull));
437 frameNodeNull->frameChildren_.insert(WeakPtr<NG::FrameNode>(childNodeNull));
438 frameNodeNull->frameChildren_.insert(WeakPtr<NG::FrameNode>(nullptr));
439 dragDropManager->AddGridDragFrameNode(parentFrameNodeTmp->GetId(), parentFrameNodeTmp);
440 dragDropManager->AddGridDragFrameNode(frameNodeNull->GetId(), frameNodeNull);
441 dragDropManager->AddGridDragFrameNode(childNodeNull->GetId(), childNodeNull);
442 std::map<int32_t, WeakPtr<FrameNode>> frameNodes = dragDropManager->gridDragFrameNodes_;
443 PointF point(100.0, 100.0);
444 auto pipeline = NG::PipelineContext::GetCurrentContext();
445 auto manager = pipeline->GetOverlayManager();
446 auto parentNode = pipeline->GetRootElement();
447 auto parentFrameNode = AceType::DynamicCast<FrameNode>(parentNode);
448 auto children = parentFrameNode->GetFrameChildren();
449 auto resultNode = dragDropManager->FindDragFrameNodeByPosition(point.GetX(), point.GetY());
450 EXPECT_TRUE(resultNode);
451 auto result = dragDropManager->FindTargetDropNode(parentNode, point);
452 EXPECT_TRUE(result);
453 }
454
455 /**
456 * @tc.name: DragDropManagerTestNgCoverage013
457 * @tc.desc: Test CheckParentVisible out of parent is a true branch.
458 * @tc.type: FUNC
459 * @tc.author:
460 */
461 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage013, TestSize.Level1)
462 {
463 /**
464 * @tc.steps: step1. construct a DragDropManager.
465 * @tc.expected: dragDropManager is not null.
466 */
467 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
468 ASSERT_NE(dragDropManager, nullptr);
469
470 RefPtr<NotifyDragEvent> notifyEvent = AceType::MakeRefPtr<NotifyDragEvent>();
471 dragDropManager->UpdateNotifyDragEvent(notifyEvent, Point(1.0f, 1.0f), DragEventType::START);
472 EXPECT_DOUBLE_EQ(notifyEvent->GetX(), 1.0);
473 EXPECT_DOUBLE_EQ(notifyEvent->GetY(), 1.0);
474
475 std::unordered_map<int32_t, WeakPtr<FrameNode>> dragEnterNodes;
476 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
477 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<GridPattern>());
478 frameNode->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE, true);
479 auto eventHub = frameNode->GetEventHub<EventHub>();
480 eventHub->SetEnabled(true);
481 dragEnterNodes[0] = nullptr;
482 dragEnterNodes[1] = frameNode;
483 dragDropManager->NotifyDragRegisterFrameNode(dragEnterNodes, DragEventType::START, notifyEvent);
484 EXPECT_TRUE(frameNode->GetPattern<Pattern>());
485 }
486
487 /**
488 * @tc.name: DragDropManagerTestNgCoverage014
489 * @tc.desc: Test PrintDragFrameNode
490 * @tc.type: FUNC
491 * @tc.author:
492 */
493 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage014, TestSize.Level1)
494 {
495 /**
496 * @tc.steps: step1. construct a DragDropManager
497 */
498 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
499 OHOS::Ace::DragPointerEvent point;
500
501 /**
502 * @tc.steps: step2. call OnDragStart
503 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
504 */
505 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
506 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, frameNodeNullId, AceType::MakeRefPtr<Pattern>());
507 dragDropManager->OnDragStart({ GLOBAL_X, GLOBAL_Y }, frameNode);
508 dragDropManager->OnItemDragStart(GLOBAL_X, GLOBAL_Y, frameNode);
509 auto draggedNode = dragDropManager->draggedFrameNode_;
510 auto preTargetNode = dragDropManager->preTargetFrameNode_;
511 dragDropManager->PrintGridDragFrameNode(GLOBAL_X, GLOBAL_Y, frameNode);
512 ASSERT_TRUE(preTargetNode);
513 dragDropManager->onDragCancel();
514 dragDropManager->onItemDragCancel();
515 dragDropManager->PrintDragFrameNode(point, frameNode);
516 dragDropManager->PrintGridDragFrameNode(GLOBAL_X, GLOBAL_Y, frameNode);
517 preTargetNode = dragDropManager->preTargetFrameNode_;
518 ASSERT_TRUE(draggedNode);
519 ASSERT_FALSE(preTargetNode);
520 }
521
522 /**
523 * @tc.name: DragDropManagerTestNgCoverage015
524 * @tc.desc: Test PrintDragFrameNode
525 * @tc.type: FUNC
526 * @tc.author:
527 */
528 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage015, TestSize.Level1)
529 {
530 /**
531 * @tc.steps: step1. construct a DragDropManager
532 */
533 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
534 dragDropManager->TransDragWindowToDragFwk(111);
535 dragDropManager->TransDragWindowToDragFwk(111);
536 ASSERT_TRUE(dragDropManager->isDragFwkShow_);
537 }
538
539 /**
540 * @tc.name: DragDropManagerTestNgCoverage016
541 * @tc.desc: Test isDistanceLimited when distance is less than the limit
542 * @tc.type: FUNC
543 * @tc.author:
544 */
545 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage016, TestSize.Level1)
546 {
547 DragDropManager dragDropManager;
548 dragDropManager.preMovePoint_ = Point(0, 0);
549 Point point(3, 4); // Distance is 5
550 EXPECT_TRUE(dragDropManager.isDistanceLimited(point));
551 }
552
553 /**
554 * @tc.name: DragDropManagerTestNgCoverage017
555 * @tc.desc: Test isDistanceLimited when distance is biger than the limit
556 * @tc.type: FUNC
557 * @tc.author:
558 */
559 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage017, TestSize.Level1)
560 {
561 DragDropManager dragDropManager;
562 dragDropManager.preMovePoint_ = Point(0, 0);
563 Point point(100 + 1, 0); // Distance is greater than MOVE_DISTANCE_LIMIT
564 EXPECT_FALSE(dragDropManager.isDistanceLimited(point));
565 }
566
567 /**
568 * @tc.name: DragDropManagerTestNgCoverage018
569 * @tc.desc: Test isTimeLimited when time interval is less than the limit
570 * @tc.type: FUNC
571 * @tc.author:
572 */
573 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage018, TestSize.Level1)
574 {
575 DragDropManager dragDropManager;
576 dragDropManager.preTimeStamp_ = 1000;
577 DragPointerEvent pointerEvent;
578 Point point(0, 0);
579 EXPECT_FALSE(dragDropManager.isTimeLimited(pointerEvent, point));
580 }
581
582 /**
583 * @tc.name: DragDropManagerTestNgCoverage019
584 * @tc.desc: Test isTimeLimited when time interval is equal to the limit
585 * @tc.type: FUNC
586 * @tc.author:
587 */
588 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage019, TestSize.Level1)
589 {
590 DragDropManager dragDropManager;
591 dragDropManager.preTimeStamp_ = 1000;
592 DragPointerEvent pointerEvent;
593 pointerEvent.time += std::chrono::milliseconds(1000); // 1000ms after preTimeStamp_
594 Point point(0, 0);
595 EXPECT_FALSE(dragDropManager.isTimeLimited(pointerEvent, point));
596 }
597
598 /**
599 * @tc.name: DragDropManagerTestNgCoverage020
600 * @tc.desc: Test isTimeLimited when time interval is greater than the limit
601 * @tc.type: FUNC
602 * @tc.author:
603 */
604 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage020, TestSize.Level1)
605 {
606 DragDropManager dragDropManager;
607 dragDropManager.preTimeStamp_ = 1000;
608 DragPointerEvent pointerEvent;
609 pointerEvent.time += std::chrono::milliseconds(2500); // 1500ms after preTimeStamp_
610 Point point(0, 0);
611 EXPECT_FALSE(dragDropManager.isTimeLimited(pointerEvent, point));
612 }
613
614 /**
615 * @tc.name: DragDropManagerTestNgCoverage021
616 * @tc.desc: Test isTimeLimited when time is the same as preTimeStamp
617 * @tc.type: FUNC
618 * @tc.author:
619 */
620 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage021, TestSize.Level1)
621 {
622 DragDropManager dragDropManager;
623 dragDropManager.preTimeStamp_ = 1000;
624 DragPointerEvent pointerEvent;
625 pointerEvent.time += std::chrono::milliseconds(1000); // Same as preTimeStamp_
626 Point point(0, 0);
627 EXPECT_FALSE(dragDropManager.isTimeLimited(pointerEvent, point));
628 }
629
630 /**
631 * @tc.name: DragDropManagerTestNgCoverage022
632 * @tc.desc: Test isTimeLimited when current time is less than preTimeStamp
633 * @tc.type: FUNC
634 * @tc.author:
635 */
636 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage022, TestSize.Level1)
637 {
638 DragDropManager dragDropManager;
639 dragDropManager.preTimeStamp_ = 2000;
640 DragPointerEvent pointerEvent;
641 pointerEvent.time += std::chrono::milliseconds(1500); // Less than preTimeStamp_
642 Point point(0, 0);
643 EXPECT_FALSE(dragDropManager.isTimeLimited(pointerEvent, point));
644 }
645
646 /**
647 * @tc.name: DragDropManagerTestNgCoverage023
648 * @tc.desc: Test ReachMoveLimit when current time is less than preTimeStamp
649 * @tc.type: FUNC
650 * @tc.author:
651 */
652 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage023, TestSize.Level1)
653 {
654 DragDropManager dragDropManager;
655 dragDropManager.preTimeStamp_ = 2000;
656 DragPointerEvent pointerEvent;
657 pointerEvent.time += std::chrono::milliseconds(2005);
658 pointerEvent.sourceTool = SourceTool::MOUSE;
659 dragDropManager.preMovePoint_ = Point(0, 0);
660 Point point(3, 4); // Distance is 5
661 EXPECT_TRUE(dragDropManager.ReachMoveLimit(pointerEvent, point));
662 }
663
664 /**
665 * @tc.name: DragDropManagerTestNgCoverage024
666 * @tc.desc: Test ReachMoveLimit when current time is less than preTimeStamp
667 * @tc.type: FUNC
668 * @tc.author:
669 */
670 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage024, TestSize.Level1)
671 {
672 DragDropManager dragDropManager;
673 dragDropManager.preTimeStamp_ = 2000;
674 DragPointerEvent pointerEvent;
675 pointerEvent.time += std::chrono::milliseconds(1000);
676 pointerEvent.sourceTool = SourceTool::MOUSE;
677 dragDropManager.preMovePoint_ = Point(0, 0);
678 Point point(15, 20); // Distance is 25
679 EXPECT_FALSE(dragDropManager.ReachMoveLimit(pointerEvent, point));
680 }
681
682 /**
683 * @tc.name: DragDropManagerTestNgCoverage025
684 * @tc.desc: Test ReachMoveLimit when current time is less than preTimeStamp
685 * @tc.type: FUNC
686 * @tc.author:
687 */
688 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage025, TestSize.Level1)
689 {
690 DragDropManager dragDropManager;
691 dragDropManager.preTimeStamp_ = 2000;
692 DragPointerEvent pointerEvent;
693 pointerEvent.time += std::chrono::milliseconds(2002);
694 pointerEvent.sourceTool = SourceTool::MOUSE;
695 dragDropManager.preMovePoint_ = Point(0, 0);
696 Point point(15, 20); // Distance is 25
697 EXPECT_FALSE(dragDropManager.ReachMoveLimit(pointerEvent, point));
698 }
699
700 /**
701 * @tc.name: DragDropManagerTestNgCoverage026
702 * @tc.desc: Test OnDragMove OnDragEnd
703 * @tc.type: FUNC
704 * @tc.author:
705 */
706 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage026, TestSize.Level1)
707 {
708 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
709 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
710 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>("parent", frameNodeNullId, AceType::MakeRefPtr<Pattern>());
711 frameNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
712 frameNodeNull->SetActive(true);
713 auto eventHub = frameNodeNull->GetEventHub<EventHub>();
714 CHECK_NULL_VOID(eventHub);
__anonbc09b1640502(const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) 715 auto onDragDrop = [](const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) {};
716 eventHub->SetOnDrop(std::move(onDragDrop));
717 auto childNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
718 auto childNodeNull =
719 AceType::MakeRefPtr<FrameNode>(V2::EMBEDDED_COMPONENT_ETS_TAG, childNodeNullId, AceType::MakeRefPtr<Pattern>());
720 childNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
721 childNodeNull->SetActive(true);
722 auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
723 geometryNode->SetFrameSize(FRAME_SIZE);
724 frameNodeNull->SetGeometryNode(geometryNode);
725 childNodeNull->SetGeometryNode(geometryNode);
726 frameNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
727 childNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
728 auto pipelineTmp = NG::PipelineContext::GetCurrentContext();
729 auto parentNodeTmp = pipelineTmp->GetRootElement();
730 auto parentFrameNodeTmp = AceType::DynamicCast<FrameNode>(parentNodeTmp);
731 parentFrameNodeTmp->SetGeometryNode(geometryNode);
732 parentFrameNodeTmp->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
733 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(frameNodeNull));
734 frameNodeNull->frameChildren_.insert(WeakPtr<NG::FrameNode>(childNodeNull));
735 frameNodeNull->frameChildren_.insert(WeakPtr<NG::FrameNode>(nullptr));
736 dragDropManager->AddGridDragFrameNode(parentFrameNodeTmp->GetId(), parentFrameNodeTmp);
737 dragDropManager->AddGridDragFrameNode(frameNodeNull->GetId(), frameNodeNull);
738 dragDropManager->AddGridDragFrameNode(childNodeNull->GetId(), childNodeNull);
739 std::map<int32_t, WeakPtr<FrameNode>> frameNodes = dragDropManager->gridDragFrameNodes_;
740 PointF point(100.0, 100.0);
741 auto pipeline = NG::PipelineContext::GetCurrentContext();
742 auto manager = pipeline->GetOverlayManager();
743 auto parentNode = pipeline->GetRootElement();
744 auto parentFrameNode = AceType::DynamicCast<FrameNode>(parentNode);
745 auto children = parentFrameNode->GetFrameChildren();
746 DragPointerEvent pointEvent(100, 100, 100, 100);
747 auto draggedNode = dragDropManager->draggedFrameNode_;
748 auto preTargetNode = dragDropManager->preTargetFrameNode_;
749 dragDropManager->isMouseDragged_ = true;
750 dragDropManager->isDragWindowShow_ = true;
751 std::string extraInfo;
752 dragDropManager->OnTextDragEnd(100, 100, extraInfo);
753 EXPECT_EQ(dragDropManager->currentId_, -1);
754 ASSERT_FALSE(draggedNode);
755 ASSERT_FALSE(preTargetNode);
756 }
757
758 /**
759 * @tc.name: DragDropManagerTestNgCoverage027
760 * @tc.desc: Test OnDragMove OnDragEnd
761 * @tc.type: FUNC
762 * @tc.author:
763 */
764 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage027, TestSize.Level1)
765 {
766 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
767 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
768 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>("parent", frameNodeNullId, AceType::MakeRefPtr<Pattern>());
769 frameNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
770 frameNodeNull->SetActive(true);
771 auto eventHub = frameNodeNull->GetEventHub<EventHub>();
772 CHECK_NULL_VOID(eventHub);
__anonbc09b1640602(const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) 773 auto onDragDrop = [](const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& value) {};
774 eventHub->SetOnDrop(std::move(onDragDrop));
775 auto childNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
776 auto childNodeNull = AceType::MakeRefPtr<FrameNode>(
777 V2::UI_EXTENSION_COMPONENT_ETS_TAG, childNodeNullId, AceType::MakeRefPtr<Pattern>());
778 childNodeNull->GetLayoutProperty()->UpdateVisibility(VisibleType::VISIBLE);
779 childNodeNull->SetActive(true);
780 auto geometryNode = AceType::MakeRefPtr<GeometryNode>();
781 geometryNode->SetFrameSize(FRAME_SIZE);
782 frameNodeNull->SetGeometryNode(geometryNode);
783 childNodeNull->SetGeometryNode(geometryNode);
784 frameNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
785 childNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
786 auto pipelineTmp = NG::PipelineContext::GetCurrentContext();
787 auto parentNodeTmp = pipelineTmp->GetRootElement();
788 auto parentFrameNodeTmp = AceType::DynamicCast<FrameNode>(parentNodeTmp);
789 parentFrameNodeTmp->SetGeometryNode(geometryNode);
790 parentFrameNodeTmp->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
791 parentFrameNodeTmp->frameChildren_.insert(WeakPtr<NG::FrameNode>(frameNodeNull));
792 frameNodeNull->frameChildren_.insert(WeakPtr<NG::FrameNode>(childNodeNull));
793 frameNodeNull->frameChildren_.insert(WeakPtr<NG::FrameNode>(nullptr));
794 dragDropManager->AddGridDragFrameNode(parentFrameNodeTmp->GetId(), parentFrameNodeTmp);
795 dragDropManager->AddGridDragFrameNode(frameNodeNull->GetId(), frameNodeNull);
796 dragDropManager->AddGridDragFrameNode(childNodeNull->GetId(), childNodeNull);
797 std::map<int32_t, WeakPtr<FrameNode>> frameNodes = dragDropManager->gridDragFrameNodes_;
798 PointF point(100.0, 100.0);
799 auto pipeline = NG::PipelineContext::GetCurrentContext();
800 auto manager = pipeline->GetOverlayManager();
801 auto parentNode = pipeline->GetRootElement();
802 auto parentFrameNode = AceType::DynamicCast<FrameNode>(parentNode);
803 auto children = parentFrameNode->GetFrameChildren();
804 DragPointerEvent pointEvent(100, 100, 100, 100);
805 auto draggedNode = dragDropManager->draggedFrameNode_;
806 auto preTargetNode = dragDropManager->preTargetFrameNode_;
807 dragDropManager->isMouseDragged_ = true;
808 dragDropManager->isDragWindowShow_ = true;
809 dragDropManager->OnDragMove(pointEvent, EXTRA_INFO);
810 dragDropManager->OnDragEnd(pointEvent, EXTRA_INFO);
811 ASSERT_FALSE(draggedNode);
812 ASSERT_FALSE(preTargetNode);
813 }
814
815 /**
816 * @tc.name: DragDropManagerTestNgCoverage028
817 * @tc.desc: Test OnDragMove OnDragEnd
818 * @tc.type: FUNC
819 * @tc.author:
820 */
821 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage028, TestSize.Level1)
822 {
823 /**
824 * @tc.steps: step1. construct a DragDropManager
825 */
826 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
827 DragPointerEvent point(100, 100, 100, 100);
828 auto frameNodeNullId = ElementRegister::GetInstance()->MakeUniqueId();
829 auto frameNodeNull = AceType::MakeRefPtr<FrameNode>("parent", frameNodeNullId, AceType::MakeRefPtr<Pattern>());
830
831 /**
832 * @tc.steps: step2. call OnDragStart
833 * @tc.expected: step2. draggedFrameNode_ & preTargetFrameNode_ are assigned to the frameNode created previously
834 */
835 frameNodeNull->GetRenderContext()->UpdatePaintRect({ 0.0, 0.0, 200.0, 200.0 });
836 auto draggedNode = dragDropManager->draggedFrameNode_;
837 auto preTargetNode = dragDropManager->preTargetFrameNode_;
838 dragDropManager->OnDragMove(point, EXTRA_INFO);
839 dragDropManager->OnDragEnd(point, EXTRA_INFO);
840 ASSERT_FALSE(draggedNode);
841 ASSERT_FALSE(preTargetNode);
842 }
843
844 /**
845 * @tc.name: DragDropManagerTestNgCoverage029
846 * @tc.desc: Test RequestDragSummaryInfoAndPrivilege
847 * @tc.type: FUNC
848 * @tc.author:
849 */
850 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage029, TestSize.Level1)
851 {
852 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
853 ASSERT_NE(dragDropManager, nullptr);
854 dragDropManager->RequestDragSummaryInfoAndPrivilege();
855 EXPECT_NE(dragDropManager, nullptr);
856 }
857
858 /**
859 * @tc.name: DragDropManagerTestNgCoverage032
860 * @tc.desc: Test CheckRemoteDat with empty udkey
861 * @tc.type: FUNC
862 * @tc.author:
863 */
864 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage032, TestSize.Level1)
865 {
866 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
867 ASSERT_NE(dragDropManager, nullptr);
868 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
869 DragPointerEvent point;
870 std::string remoteUdKey;
871 auto result = dragDropManager->CheckRemoteData(frameNode, point, remoteUdKey);
872 EXPECT_FALSE(result);
873 }
874
875 /**
876 * @tc.name: DragDropManagerTestNgCoverage033
877 * @tc.desc: Test CheckRemoteDat with isRemoteData
878 * @tc.type: FUNC
879 * @tc.author:
880 */
881 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage033, TestSize.Level1)
882 {
883 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
884 ASSERT_NE(dragDropManager, nullptr);
885 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
886 DragPointerEvent point;
887 std::string remoteUdKey = "abc";
888 auto mockUdmfClient = static_cast<MockUdmfClient*>(UdmfClient::GetInstance());
889 EXPECT_CALL(*mockUdmfClient, GetRemoteStatus(testing::_)).WillOnce(testing::Return(true));
890 auto result = dragDropManager->CheckRemoteData(frameNode, point, remoteUdKey);
891 EXPECT_TRUE(result);
892 }
893
894 /**
895 * @tc.name: DragDropManagerTestNgCoverage034
896 * @tc.desc: Test RequestUDMFDataWithUDKey
897 * @tc.type: FUNC
898 * @tc.author:
899 */
900 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage034, TestSize.Level1)
901 {
902 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
903 ASSERT_NE(dragDropManager, nullptr);
904 std::string remoteUdKey = "abc";
905 auto mockUdmfClient = static_cast<MockUdmfClient*>(UdmfClient::GetInstance());
906 EXPECT_CALL(*mockUdmfClient, GetData(testing::_, testing::_)).Times(1).WillOnce(testing::Return(1));
907 auto result = dragDropManager->RequestUDMFDataWithUDKey(remoteUdKey);
908 EXPECT_EQ(result, nullptr);
909 }
910
911 /**
912 * @tc.name: DragDropManagerTestNgCoverage035
913 * @tc.desc: Test RequestUDMFDataWithUDKey
914 * @tc.type: FUNC
915 * @tc.author:
916 */
917 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage035, TestSize.Level1)
918 {
919 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
920 ASSERT_NE(dragDropManager, nullptr);
921 std::string remoteUdKey;
922 auto result = dragDropManager->RequestUDMFDataWithUDKey(remoteUdKey);
923 EXPECT_EQ(result, nullptr);
924 }
925
926 /**
927 * @tc.name: DragDropManagerTestNgCoverage036
928 * @tc.desc: Test RequestUDMFDataWithUDKey
929 * @tc.type: FUNC
930 * @tc.author:
931 */
932 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage036, TestSize.Level1)
933 {
934 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
935 ASSERT_NE(dragDropManager, nullptr);
936 std::string remoteUdKey = "ABC";
937 auto mockUdmfClient = static_cast<MockUdmfClient*>(UdmfClient::GetInstance());
938 EXPECT_CALL(*mockUdmfClient, GetData(testing::_, testing::_)).Times(1).WillOnce(testing::Return(0));
939 auto result = dragDropManager->RequestUDMFDataWithUDKey(remoteUdKey);
940 EXPECT_EQ(result, nullptr);
941 }
942
943 /**
944 * @tc.name: DragDropManagerTestNgCoverage037
945 * @tc.desc: Test DoDropAction
946 * @tc.type: FUNC
947 * @tc.author:
948 */
949 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage037, TestSize.Level1)
950 {
951 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
952 ASSERT_NE(dragDropManager, nullptr);
953 std::string remoteUdKey = "abc";
954 RefPtr<UnifiedData> unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
955 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
956 DragPointerEvent point;
957 dragDropManager->DoDropAction(frameNode, point, unifiedData, remoteUdKey);
958 EXPECT_NE(unifiedData, nullptr);
959 }
960
961 /**
962 * @tc.name: DragDropManagerTestNgCoverage038
963 * @tc.desc: Test DoDropAction
964 * @tc.type: FUNC
965 * @tc.author:
966 */
967 HWTEST_F(DragDropManagerTestNgCoverage, DragDropManagerTestNgCoverage038, TestSize.Level1)
968 {
969 auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
970 ASSERT_NE(dragDropManager, nullptr);
971 std::string remoteUdKey;
972 auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
973 DragPointerEvent point;
974 dragDropManager->DoDropAction(frameNode, point, nullptr, remoteUdKey);
975 EXPECT_NE(frameNode, nullptr);
976 }
977 } // namespace OHOS::Ace::NG