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