1 /*
2  * Copyright (c) 2022 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 
16 #include <optional>
17 
18 #include "gtest/gtest.h"
19 
20 #define private public
21 #include "test/mock/base/mock_drag_window.h"
22 #include "test/mock/core/common/mock_container.h"
23 #include "test/mock/core/common/mock_interaction_interface.h"
24 #include "test/mock/core/pipeline/mock_pipeline_context.h"
25 
26 #include "base/geometry/ng/offset_t.h"
27 #include "base/geometry/ng/rect_t.h"
28 #include "base/geometry/ng/size_t.h"
29 #include "base/image/pixel_map.h"
30 #include "base/memory/ace_type.h"
31 #include "base/memory/referenced.h"
32 #include "base/subwindow/subwindow_manager.h"
33 #include "core/common/interaction/interaction_interface.h"
34 #include "core/components/common/layout/grid_system_manager.h"
35 #include "core/components_ng/base/frame_node.h"
36 #include "core/components_ng/base/geometry_node.h"
37 #include "core/components_ng/base/ui_node.h"
38 #include "core/components_ng/event/event_hub.h"
39 #include "core/components_ng/manager/drag_drop/drag_drop_manager.h"
40 #include "core/components_ng/manager/drag_drop/drag_drop_proxy.h"
41 #include "core/components_ng/pattern/grid/grid_event_hub.h"
42 #include "core/components_ng/pattern/grid/grid_pattern.h"
43 #include "core/components_ng/pattern/list/list_event_hub.h"
44 #include "core/components_ng/pattern/list/list_pattern.h"
45 #include "core/components_ng/pattern/pattern.h"
46 #include "core/components_ng/pattern/text/text_pattern.h"
47 #include "core/components_v2/inspector/inspector_constants.h"
48 #include "core/pipeline/base/render_node.h"
49 
50 using namespace testing;
51 using namespace testing::ext;
52 namespace OHOS::Ace::NG {
53 namespace {
54 const std::string NODE_TAG("custom_node");
55 const std::string EXTRA_INFO("extra info");
56 constexpr int32_t GLOBAL_1 = 1;
57 constexpr int32_t GLOBAL_2 = 2;
58 constexpr int32_t GLOBAL_3 = 3;
59 RefPtr<DragWindow> MOCK_DRAG_WINDOW;
60 } // namespace
61 
62 class DragDropReportTestNg : public testing::Test {
63 public:
64     static void SetUpTestCase();
65     static void TearDownTestCase();
66 };
67 
SetUpTestCase()68 void DragDropReportTestNg::SetUpTestCase()
69 {
70     MockPipelineContext::SetUp();
71     MockContainer::SetUp();
72     MOCK_DRAG_WINDOW = DragWindow::CreateDragWindow("", 0, 0, 0, 0);
73 }
74 
TearDownTestCase()75 void DragDropReportTestNg::TearDownTestCase()
76 {
77     MockPipelineContext::TearDown();
78     MockContainer::TearDown();
79     MOCK_DRAG_WINDOW = nullptr;
80 }
81 
82 /**
83  * @tc.name: DragDropReportTest001
84  * @tc.desc: Test DragEventStrictReportingEnabled
85  * @tc.type: FUNC
86  * @tc.author:
87  */
88 HWTEST_F(DragDropReportTestNg, DragDropReportTest001, TestSize.Level1)
89 {
90     /**
91      * @tc.steps: step1. construct a DragDropManager.
92      * @tc.expected: dragDropManager is not null.
93      */
94     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
95     ASSERT_NE(dragDropManager, nullptr);
96 
97     /**
98      * @tc.steps: step2. ReportingEnable is not set.
99      * @tc.expected: reportingEnabledDefault is false.
100      */
101     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
102     ASSERT_FALSE(reportingEnabledDefault);
103     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
104     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
105     auto preTargetNode = dragDropManager->preTargetFrameNode_;
106     ASSERT_TRUE(preTargetNode);
107     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
108     ASSERT_TRUE(preTargetNode);
109     ASSERT_FALSE(reportingEnabledDefault);
110     preTargetNode.Reset();
111     frameNode.Reset();
112 
113     /**
114      * @tc.steps: step3. ReportingSupported is set to true.
115      * @tc.expected: reportingEnabledTrue is true.
116      */
117     bool variableTrue = true;
118     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
119     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
120     ASSERT_TRUE(reportingEnabledTrue);
121     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
122     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
123     preTargetNode = dragDropManager->preTargetFrameNode_;
124     ASSERT_TRUE(preTargetNode);
125     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
126     ASSERT_TRUE(preTargetNode);
127     ASSERT_TRUE(reportingEnabledTrue);
128     preTargetNode.Reset();
129     frameNode.Reset();
130 
131     /**
132      * @tc.steps: step4. ReportingSupported is set to false.
133      * @tc.expected: reportingEnabledFalse is false.
134      */
135     bool variableFalse = false;
136     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
137     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
138     ASSERT_FALSE(reportingEnabledFalse);
139     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
140     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
141     preTargetNode = dragDropManager->preTargetFrameNode_;
142     ASSERT_TRUE(preTargetNode);
143     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
144     ASSERT_TRUE(preTargetNode);
145     ASSERT_FALSE(reportingEnabledFalse);
146 }
147 
148 /**
149  * @tc.name: DragDropReportTest002
150  * @tc.desc: Test DragEventStrictReportingEnabled
151  * @tc.type: FUNC
152  * @tc.author:
153  */
154 HWTEST_F(DragDropReportTestNg, DragDropReportTest002, TestSize.Level1)
155 {
156     /**
157      * @tc.steps: step1. construct a DragDropManager.
158      * @tc.expected: dragDropManager is not null.
159      */
160     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
161     ASSERT_NE(dragDropManager, nullptr);
162 
163     /**
164      * @tc.steps: step2. ReportingEnable is not set.
165      * @tc.expected: reportingEnabledDefault is false.
166      */
167     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
168     ASSERT_FALSE(reportingEnabledDefault);
169     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
170     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
171     auto preTargetNode = dragDropManager->preTargetFrameNode_;
172     ASSERT_TRUE(preTargetNode);
173     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
174     ASSERT_TRUE(preTargetNode);
175     ASSERT_FALSE(reportingEnabledDefault);
176     preTargetNode.Reset();
177     frameNode.Reset();
178 
179     /**
180      * @tc.steps: step3. ReportingSupported is set to true.
181      * @tc.expected: reportingEnabledTrue is true.
182      */
183     bool variableTrue = true;
184     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
185     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
186     ASSERT_TRUE(reportingEnabledTrue);
187     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
188     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
189     preTargetNode = dragDropManager->preTargetFrameNode_;
190     ASSERT_TRUE(preTargetNode);
191     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
192     ASSERT_TRUE(preTargetNode);
193     ASSERT_TRUE(reportingEnabledTrue);
194     preTargetNode.Reset();
195     frameNode.Reset();
196 
197     /**
198      * @tc.steps: step4. ReportingSupported is set to false.
199      * @tc.expected: reportingEnabledFalse is false.
200      */
201     bool variableFalse = false;
202     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
203     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
204     ASSERT_FALSE(reportingEnabledFalse);
205     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
206     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
207     preTargetNode = dragDropManager->preTargetFrameNode_;
208     ASSERT_TRUE(preTargetNode);
209     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
210     ASSERT_TRUE(preTargetNode);
211     ASSERT_FALSE(reportingEnabledFalse);
212 }
213 
214 /**
215  * @tc.name: DragDropReportTest003
216  * @tc.desc: Test DragEventStrictReportingEnabled
217  * @tc.type: FUNC
218  * @tc.author:
219  */
220 HWTEST_F(DragDropReportTestNg, DragDropReportTest003, TestSize.Level1)
221 {
222     /**
223      * @tc.steps: step1. construct a DragDropManager.
224      * @tc.expected: dragDropManager is not null.
225      */
226     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
227     ASSERT_NE(dragDropManager, nullptr);
228 
229     /**
230      * @tc.steps: step2. ReportingEnable is not set.
231      * @tc.expected: reportingEnabledDefault is false.
232      */
233     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
234     ASSERT_FALSE(reportingEnabledDefault);
235     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
236     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
237     auto preTargetNode = dragDropManager->preTargetFrameNode_;
238     ASSERT_TRUE(preTargetNode);
239     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
240     ASSERT_TRUE(preTargetNode);
241     ASSERT_FALSE(reportingEnabledDefault);
242     preTargetNode.Reset();
243     frameNode.Reset();
244 
245     /**
246      * @tc.steps: step3. ReportingSupported is set to true.
247      * @tc.expected: reportingEnabledTrue is true.
248      */
249     bool variableTrue = true;
250     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
251     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
252     ASSERT_TRUE(reportingEnabledTrue);
253     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
254     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
255     preTargetNode = dragDropManager->preTargetFrameNode_;
256     ASSERT_TRUE(preTargetNode);
257     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
258     ASSERT_TRUE(preTargetNode);
259     ASSERT_TRUE(reportingEnabledTrue);
260     preTargetNode.Reset();
261     frameNode.Reset();
262 
263     /**
264      * @tc.steps: step4. ReportingSupported is set to false.
265      * @tc.expected: reportingEnabledFalse is false.
266      */
267     bool variableFalse = false;
268     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
269     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
270     ASSERT_FALSE(reportingEnabledFalse);
271     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
272     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
273     preTargetNode = dragDropManager->preTargetFrameNode_;
274     ASSERT_TRUE(preTargetNode);
275     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
276     ASSERT_TRUE(preTargetNode);
277     ASSERT_FALSE(reportingEnabledFalse);
278 }
279 
280 /**
281  * @tc.name: DragDropReportTest004
282  * @tc.desc: Test DragEventStrictReportingEnabled
283  * @tc.type: FUNC
284  * @tc.author:
285  */
286 HWTEST_F(DragDropReportTestNg, DragDropReportTest004, TestSize.Level1)
287 {
288     /**
289      * @tc.steps: step1. construct a DragDropManager.
290      * @tc.expected: dragDropManager is not null.
291      */
292     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
293     ASSERT_NE(dragDropManager, nullptr);
294 
295     /**
296      * @tc.steps: step2. ReportingEnable is not set.
297      * @tc.expected: reportingEnabledDefault is false.
298      */
299     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
300     ASSERT_FALSE(reportingEnabledDefault);
301     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
302     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
303     auto preTargetNode = dragDropManager->preTargetFrameNode_;
304     ASSERT_TRUE(preTargetNode);
305     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
306     ASSERT_TRUE(preTargetNode);
307     ASSERT_FALSE(reportingEnabledDefault);
308     preTargetNode.Reset();
309     frameNode.Reset();
310 
311     /**
312      * @tc.steps: step3. ReportingSupported is set to true.
313      * @tc.expected: reportingEnabledTrue is true.
314      */
315     bool variableTrue = true;
316     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
317     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
318     ASSERT_TRUE(reportingEnabledTrue);
319     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
320     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
321     preTargetNode = dragDropManager->preTargetFrameNode_;
322     ASSERT_TRUE(preTargetNode);
323     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
324     ASSERT_TRUE(preTargetNode);
325     ASSERT_TRUE(reportingEnabledTrue);
326     preTargetNode.Reset();
327     frameNode.Reset();
328 
329     /**
330      * @tc.steps: step4. ReportingSupported is set to false.
331      * @tc.expected: reportingEnabledFalse is false.
332      */
333     bool variableFalse = false;
334     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
335     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
336     ASSERT_FALSE(reportingEnabledFalse);
337     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
338     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
339     preTargetNode = dragDropManager->preTargetFrameNode_;
340     ASSERT_TRUE(preTargetNode);
341     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
342     ASSERT_TRUE(preTargetNode);
343     ASSERT_FALSE(reportingEnabledFalse);
344 }
345 
346 /**
347  * @tc.name: DragDropReportTest005
348  * @tc.desc: Test DragEventStrictReportingEnabled
349  * @tc.type: FUNC
350  * @tc.author:
351  */
352 HWTEST_F(DragDropReportTestNg, DragDropReportTest005, TestSize.Level1)
353 {
354     /**
355      * @tc.steps: step1. construct a DragDropManager.
356      * @tc.expected: dragDropManager is not null.
357      */
358     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
359     ASSERT_NE(dragDropManager, nullptr);
360 
361     /**
362      * @tc.steps: step2. ReportingEnable is not set.
363      * @tc.expected: reportingEnabledDefault is false.
364      */
365     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
366     ASSERT_FALSE(reportingEnabledDefault);
367     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
368     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
369     auto preTargetNode = dragDropManager->preTargetFrameNode_;
370     ASSERT_TRUE(preTargetNode);
371     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
372     ASSERT_TRUE(preTargetNode);
373     ASSERT_FALSE(reportingEnabledDefault);
374     preTargetNode.Reset();
375     frameNode.Reset();
376 
377     /**
378      * @tc.steps: step3. ReportingSupported is set to true.
379      * @tc.expected: reportingEnabledTrue is true.
380      */
381     bool variableTrue = true;
382     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
383     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
384     ASSERT_TRUE(reportingEnabledTrue);
385     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
386     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
387     preTargetNode = dragDropManager->preTargetFrameNode_;
388     ASSERT_TRUE(preTargetNode);
389     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
390     ASSERT_TRUE(preTargetNode);
391     ASSERT_TRUE(reportingEnabledTrue);
392     preTargetNode.Reset();
393     frameNode.Reset();
394 
395     /**
396      * @tc.steps: step4. ReportingSupported is set to false.
397      * @tc.expected: reportingEnabledFalse is false.
398      */
399     bool variableFalse = false;
400     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
401     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
402     ASSERT_FALSE(reportingEnabledFalse);
403     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
404     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
405     preTargetNode = dragDropManager->preTargetFrameNode_;
406     ASSERT_TRUE(preTargetNode);
407     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_1 }, EXTRA_INFO);
408     ASSERT_TRUE(preTargetNode);
409     ASSERT_FALSE(reportingEnabledFalse);
410 }
411 
412 /**
413  * @tc.name: DragDropReportTest006
414  * @tc.desc: Test DragEventStrictReportingEnabled
415  * @tc.type: FUNC
416  * @tc.author:
417  */
418 HWTEST_F(DragDropReportTestNg, DragDropReportTest006, TestSize.Level1)
419 {
420     /**
421      * @tc.steps: step1. construct a DragDropManager.
422      * @tc.expected: dragDropManager is not null.
423      */
424     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
425     ASSERT_NE(dragDropManager, nullptr);
426 
427     /**
428      * @tc.steps: step2. ReportingEnable is not set.
429      * @tc.expected: reportingEnabledDefault is false.
430      */
431     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
432     ASSERT_FALSE(reportingEnabledDefault);
433     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
434     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
435     auto preTargetNode = dragDropManager->preTargetFrameNode_;
436     ASSERT_TRUE(preTargetNode);
437     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
438     ASSERT_TRUE(preTargetNode);
439     ASSERT_FALSE(reportingEnabledDefault);
440     preTargetNode.Reset();
441     frameNode.Reset();
442 
443     /**
444      * @tc.steps: step3. ReportingSupported is set to true.
445      * @tc.expected: reportingEnabledTrue is true.
446      */
447     bool variableTrue = true;
448     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
449     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
450     ASSERT_TRUE(reportingEnabledTrue);
451     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
452     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
453     preTargetNode = dragDropManager->preTargetFrameNode_;
454     ASSERT_TRUE(preTargetNode);
455     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
456     ASSERT_TRUE(preTargetNode);
457     ASSERT_TRUE(reportingEnabledTrue);
458     preTargetNode.Reset();
459     frameNode.Reset();
460 
461     /**
462      * @tc.steps: step4. ReportingSupported is set to false.
463      * @tc.expected: reportingEnabledFalse is false.
464      */
465     bool variableFalse = false;
466     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
467     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
468     ASSERT_FALSE(reportingEnabledFalse);
469     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
470     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
471     preTargetNode = dragDropManager->preTargetFrameNode_;
472     ASSERT_TRUE(preTargetNode);
473     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
474     ASSERT_TRUE(preTargetNode);
475     ASSERT_FALSE(reportingEnabledFalse);
476 }
477 
478 /**
479  * @tc.name: DragDropReportTest007
480  * @tc.desc: Test DragEventStrictReportingEnabled
481  * @tc.type: FUNC
482  * @tc.author:
483  */
484 HWTEST_F(DragDropReportTestNg, DragDropReportTest007, TestSize.Level1)
485 {
486     /**
487      * @tc.steps: step1. construct a DragDropManager.
488      * @tc.expected: dragDropManager is not null.
489      */
490     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
491     ASSERT_NE(dragDropManager, nullptr);
492 
493     /**
494      * @tc.steps: step2. ReportingEnable is not set.
495      * @tc.expected: reportingEnabledDefault is false.
496      */
497     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
498     ASSERT_FALSE(reportingEnabledDefault);
499     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
500     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
501     auto preTargetNode = dragDropManager->preTargetFrameNode_;
502     ASSERT_TRUE(preTargetNode);
503     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
504     ASSERT_TRUE(preTargetNode);
505     ASSERT_FALSE(reportingEnabledDefault);
506     preTargetNode.Reset();
507     frameNode.Reset();
508 
509     /**
510      * @tc.steps: step3. ReportingSupported is set to true.
511      * @tc.expected: reportingEnabledTrue is true.
512      */
513     bool variableTrue = true;
514     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
515     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
516     ASSERT_TRUE(reportingEnabledTrue);
517     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
518     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
519     preTargetNode = dragDropManager->preTargetFrameNode_;
520     ASSERT_TRUE(preTargetNode);
521     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
522     ASSERT_TRUE(preTargetNode);
523     ASSERT_TRUE(reportingEnabledTrue);
524     preTargetNode.Reset();
525     frameNode.Reset();
526 
527     /**
528      * @tc.steps: step4. ReportingSupported is set to false.
529      * @tc.expected: reportingEnabledFalse is false.
530      */
531     bool variableFalse = false;
532     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
533     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
534     ASSERT_FALSE(reportingEnabledFalse);
535     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
536     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
537     preTargetNode = dragDropManager->preTargetFrameNode_;
538     ASSERT_TRUE(preTargetNode);
539     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
540     ASSERT_TRUE(preTargetNode);
541     ASSERT_FALSE(reportingEnabledFalse);
542 }
543 
544 /**
545  * @tc.name: DragDropReportTest008
546  * @tc.desc: Test DragEventStrictReportingEnabled
547  * @tc.type: FUNC
548  * @tc.author:
549  */
550 HWTEST_F(DragDropReportTestNg, DragDropReportTest008, TestSize.Level1)
551 {
552     /**
553      * @tc.steps: step1. construct a DragDropManager.
554      * @tc.expected: dragDropManager is not null.
555      */
556     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
557     ASSERT_NE(dragDropManager, nullptr);
558 
559     /**
560      * @tc.steps: step2. ReportingEnable is not set.
561      * @tc.expected: reportingEnabledDefault is false.
562      */
563     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
564     ASSERT_FALSE(reportingEnabledDefault);
565     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
566     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
567     auto preTargetNode = dragDropManager->preTargetFrameNode_;
568     ASSERT_TRUE(preTargetNode);
569     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
570     ASSERT_TRUE(preTargetNode);
571     ASSERT_FALSE(reportingEnabledDefault);
572     preTargetNode.Reset();
573     frameNode.Reset();
574 
575     /**
576      * @tc.steps: step3. ReportingSupported is set to true.
577      * @tc.expected: reportingEnabledTrue is true.
578      */
579     bool variableTrue = true;
580     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
581     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
582     ASSERT_TRUE(reportingEnabledTrue);
583     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
584     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
585     preTargetNode = dragDropManager->preTargetFrameNode_;
586     ASSERT_TRUE(preTargetNode);
587     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
588     ASSERT_TRUE(preTargetNode);
589     ASSERT_TRUE(reportingEnabledTrue);
590     preTargetNode.Reset();
591     frameNode.Reset();
592 
593     /**
594      * @tc.steps: step4. ReportingSupported is set to false.
595      * @tc.expected: reportingEnabledFalse is false.
596      */
597     bool variableFalse = false;
598     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
599     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
600     ASSERT_FALSE(reportingEnabledFalse);
601     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
602     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
603     preTargetNode = dragDropManager->preTargetFrameNode_;
604     ASSERT_TRUE(preTargetNode);
605     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
606     ASSERT_TRUE(preTargetNode);
607     ASSERT_FALSE(reportingEnabledFalse);
608 }
609 
610 /**
611  * @tc.name: DragDropReportTest009
612  * @tc.desc: Test DragEventStrictReportingEnabled
613  * @tc.type: FUNC
614  * @tc.author:
615  */
616 HWTEST_F(DragDropReportTestNg, DragDropReportTest009, TestSize.Level1)
617 {
618     /**
619      * @tc.steps: step1. construct a DragDropManager.
620      * @tc.expected: dragDropManager is not null.
621      */
622     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
623     ASSERT_NE(dragDropManager, nullptr);
624 
625     /**
626      * @tc.steps: step2. ReportingEnable is not set.
627      * @tc.expected: reportingEnabledDefault is false.
628      */
629     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
630     ASSERT_FALSE(reportingEnabledDefault);
631     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
632     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
633     auto preTargetNode = dragDropManager->preTargetFrameNode_;
634     ASSERT_TRUE(preTargetNode);
635     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
636     ASSERT_TRUE(preTargetNode);
637     ASSERT_FALSE(reportingEnabledDefault);
638     preTargetNode.Reset();
639     frameNode.Reset();
640 
641     /**
642      * @tc.steps: step3. ReportingSupported is set to true.
643      * @tc.expected: reportingEnabledTrue is true.
644      */
645     bool variableTrue = true;
646     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
647     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
648     ASSERT_TRUE(reportingEnabledTrue);
649     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
650     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
651     preTargetNode = dragDropManager->preTargetFrameNode_;
652     ASSERT_TRUE(preTargetNode);
653     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
654     ASSERT_TRUE(preTargetNode);
655     ASSERT_TRUE(reportingEnabledTrue);
656     preTargetNode.Reset();
657     frameNode.Reset();
658 
659     /**
660      * @tc.steps: step4. ReportingSupported is set to false.
661      * @tc.expected: reportingEnabledFalse is false.
662      */
663     bool variableFalse = false;
664     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
665     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
666     ASSERT_FALSE(reportingEnabledFalse);
667     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
668     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
669     preTargetNode = dragDropManager->preTargetFrameNode_;
670     ASSERT_TRUE(preTargetNode);
671     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
672     ASSERT_TRUE(preTargetNode);
673     ASSERT_FALSE(reportingEnabledFalse);
674 }
675 
676 /**
677  * @tc.name: DragDropReportTest010
678  * @tc.desc: Test DragEventStrictReportingEnabled
679  * @tc.type: FUNC
680  * @tc.author:
681  */
682 HWTEST_F(DragDropReportTestNg, DragDropReportTest010, TestSize.Level1)
683 {
684     /**
685      * @tc.steps: step1. construct a DragDropManager.
686      * @tc.expected: dragDropManager is not null.
687      */
688     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
689     ASSERT_NE(dragDropManager, nullptr);
690 
691     /**
692      * @tc.steps: step2. ReportingEnable is not set.
693      * @tc.expected: reportingEnabledDefault is false.
694      */
695     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
696     ASSERT_FALSE(reportingEnabledDefault);
697     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
698     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
699     auto preTargetNode = dragDropManager->preTargetFrameNode_;
700     ASSERT_TRUE(preTargetNode);
701     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
702     ASSERT_TRUE(preTargetNode);
703     ASSERT_FALSE(reportingEnabledDefault);
704     preTargetNode.Reset();
705     frameNode.Reset();
706 
707     /**
708      * @tc.steps: step3. ReportingSupported is set to true.
709      * @tc.expected: reportingEnabledTrue is true.
710      */
711     bool variableTrue = true;
712     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
713     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
714     ASSERT_TRUE(reportingEnabledTrue);
715     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
716     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
717     preTargetNode = dragDropManager->preTargetFrameNode_;
718     ASSERT_TRUE(preTargetNode);
719     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
720     ASSERT_TRUE(preTargetNode);
721     ASSERT_TRUE(reportingEnabledTrue);
722     preTargetNode.Reset();
723     frameNode.Reset();
724 
725     /**
726      * @tc.steps: step4. ReportingSupported is set to false.
727      * @tc.expected: reportingEnabledFalse is false.
728      */
729     bool variableFalse = false;
730     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
731     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
732     ASSERT_FALSE(reportingEnabledFalse);
733     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
734     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
735     preTargetNode = dragDropManager->preTargetFrameNode_;
736     ASSERT_TRUE(preTargetNode);
737     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
738     ASSERT_TRUE(preTargetNode);
739     ASSERT_FALSE(reportingEnabledFalse);
740 }
741 
742 /**
743  * @tc.name: DragDropReportTest011
744  * @tc.desc: Test DragEventStrictReportingEnabled
745  * @tc.type: FUNC
746  * @tc.author:
747  */
748 HWTEST_F(DragDropReportTestNg, DragDropReportTest011, TestSize.Level1)
749 {
750     /**
751      * @tc.steps: step1. construct a DragDropManager.
752      * @tc.expected: dragDropManager is not null.
753      */
754     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
755     ASSERT_NE(dragDropManager, nullptr);
756 
757     /**
758      * @tc.steps: step2. ReportingEnable is not set.
759      * @tc.expected: reportingEnabledDefault is false.
760      */
761     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
762     ASSERT_FALSE(reportingEnabledDefault);
763     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
764     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
765     auto preTargetNode = dragDropManager->preTargetFrameNode_;
766     ASSERT_TRUE(preTargetNode);
767     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
768     ASSERT_TRUE(preTargetNode);
769     ASSERT_FALSE(reportingEnabledDefault);
770     preTargetNode.Reset();
771     frameNode.Reset();
772 
773     /**
774      * @tc.steps: step3. ReportingSupported is set to true.
775      * @tc.expected: reportingEnabledTrue is true.
776      */
777     bool variableTrue = true;
778     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
779     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
780     ASSERT_TRUE(reportingEnabledTrue);
781     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
782     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
783     preTargetNode = dragDropManager->preTargetFrameNode_;
784     ASSERT_TRUE(preTargetNode);
785     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
786     ASSERT_TRUE(preTargetNode);
787     ASSERT_TRUE(reportingEnabledTrue);
788     preTargetNode.Reset();
789     frameNode.Reset();
790 
791     /**
792      * @tc.steps: step4. ReportingSupported is set to false.
793      * @tc.expected: reportingEnabledFalse is false.
794      */
795     bool variableFalse = false;
796     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
797     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
798     ASSERT_FALSE(reportingEnabledFalse);
799     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
800     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
801     preTargetNode = dragDropManager->preTargetFrameNode_;
802     ASSERT_TRUE(preTargetNode);
803     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
804     ASSERT_TRUE(preTargetNode);
805     ASSERT_FALSE(reportingEnabledFalse);
806 }
807 
808 /**
809  * @tc.name: DragDropReportTest012
810  * @tc.desc: Test DragEventStrictReportingEnabled
811  * @tc.type: FUNC
812  * @tc.author:
813  */
814 HWTEST_F(DragDropReportTestNg, DragDropReportTest012, TestSize.Level1)
815 {
816     /**
817      * @tc.steps: step1. construct a DragDropManager.
818      * @tc.expected: dragDropManager is not null.
819      */
820     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
821     ASSERT_NE(dragDropManager, nullptr);
822 
823     /**
824      * @tc.steps: step2. ReportingEnable is not set.
825      * @tc.expected: reportingEnabledDefault is false.
826      */
827     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
828     ASSERT_FALSE(reportingEnabledDefault);
829     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
830     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
831     auto preTargetNode = dragDropManager->preTargetFrameNode_;
832     ASSERT_TRUE(preTargetNode);
833     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
834     ASSERT_TRUE(preTargetNode);
835     ASSERT_FALSE(reportingEnabledDefault);
836     preTargetNode.Reset();
837     frameNode.Reset();
838 
839     /**
840      * @tc.steps: step3. ReportingSupported is set to true.
841      * @tc.expected: reportingEnabledTrue is true.
842      */
843     bool variableTrue = true;
844     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
845     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
846     ASSERT_TRUE(reportingEnabledTrue);
847     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
848     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
849     preTargetNode = dragDropManager->preTargetFrameNode_;
850     ASSERT_TRUE(preTargetNode);
851     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
852     ASSERT_TRUE(preTargetNode);
853     ASSERT_TRUE(reportingEnabledTrue);
854     preTargetNode.Reset();
855     frameNode.Reset();
856 
857     /**
858      * @tc.steps: step4. ReportingSupported is set to false.
859      * @tc.expected: reportingEnabledFalse is false.
860      */
861     bool variableFalse = false;
862     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
863     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
864     ASSERT_FALSE(reportingEnabledFalse);
865     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
866     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
867     preTargetNode = dragDropManager->preTargetFrameNode_;
868     ASSERT_TRUE(preTargetNode);
869     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
870     ASSERT_TRUE(preTargetNode);
871     ASSERT_FALSE(reportingEnabledFalse);
872 }
873 
874 /**
875  * @tc.name: DragDropReportTest013
876  * @tc.desc: Test DragEventStrictReportingEnabled
877  * @tc.type: FUNC
878  * @tc.author:
879  */
880 HWTEST_F(DragDropReportTestNg, DragDropReportTest013, TestSize.Level1)
881 {
882     /**
883      * @tc.steps: step1. construct a DragDropManager.
884      * @tc.expected: dragDropManager is not null.
885      */
886     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
887     ASSERT_NE(dragDropManager, nullptr);
888 
889     /**
890      * @tc.steps: step2. ReportingEnable is not set.
891      * @tc.expected: reportingEnabledDefault is false.
892      */
893     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
894     ASSERT_FALSE(reportingEnabledDefault);
895     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
896     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
897     auto preTargetNode = dragDropManager->preTargetFrameNode_;
898     ASSERT_TRUE(preTargetNode);
899     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
900     ASSERT_TRUE(preTargetNode);
901     ASSERT_FALSE(reportingEnabledDefault);
902     preTargetNode.Reset();
903     frameNode.Reset();
904 
905     /**
906      * @tc.steps: step3. ReportingSupported is set to true.
907      * @tc.expected: reportingEnabledTrue is true.
908      */
909     bool variableTrue = true;
910     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
911     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
912     ASSERT_TRUE(reportingEnabledTrue);
913     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
914     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
915     preTargetNode = dragDropManager->preTargetFrameNode_;
916     ASSERT_TRUE(preTargetNode);
917     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
918     ASSERT_TRUE(preTargetNode);
919     ASSERT_TRUE(reportingEnabledTrue);
920     preTargetNode.Reset();
921     frameNode.Reset();
922 
923     /**
924      * @tc.steps: step4. ReportingSupported is set to false.
925      * @tc.expected: reportingEnabledFalse is false.
926      */
927     bool variableFalse = false;
928     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
929     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
930     ASSERT_FALSE(reportingEnabledFalse);
931     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
932     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
933     preTargetNode = dragDropManager->preTargetFrameNode_;
934     ASSERT_TRUE(preTargetNode);
935     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
936     ASSERT_TRUE(preTargetNode);
937     ASSERT_FALSE(reportingEnabledFalse);
938 }
939 
940 /**
941  * @tc.name: DragDropReportTest014
942  * @tc.desc: Test DragEventStrictReportingEnabled
943  * @tc.type: FUNC
944  * @tc.author:
945  */
946 HWTEST_F(DragDropReportTestNg, DragDropReportTest014, TestSize.Level1)
947 {
948     /**
949      * @tc.steps: step1. construct a DragDropManager.
950      * @tc.expected: dragDropManager is not null.
951      */
952     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
953     ASSERT_NE(dragDropManager, nullptr);
954 
955     /**
956      * @tc.steps: step2. ReportingEnable is not set.
957      * @tc.expected: reportingEnabledDefault is false.
958      */
959     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
960     ASSERT_FALSE(reportingEnabledDefault);
961     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
962     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
963     auto preTargetNode = dragDropManager->preTargetFrameNode_;
964     ASSERT_TRUE(preTargetNode);
965     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
966     ASSERT_TRUE(preTargetNode);
967     ASSERT_FALSE(reportingEnabledDefault);
968     preTargetNode.Reset();
969     frameNode.Reset();
970 
971     /**
972      * @tc.steps: step3. ReportingSupported is set to true.
973      * @tc.expected: reportingEnabledTrue is true.
974      */
975     bool variableTrue = true;
976     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
977     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
978     ASSERT_TRUE(reportingEnabledTrue);
979     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
980     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
981     preTargetNode = dragDropManager->preTargetFrameNode_;
982     ASSERT_TRUE(preTargetNode);
983     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
984     ASSERT_TRUE(preTargetNode);
985     ASSERT_TRUE(reportingEnabledTrue);
986     preTargetNode.Reset();
987     frameNode.Reset();
988 
989     /**
990      * @tc.steps: step4. ReportingSupported is set to false.
991      * @tc.expected: reportingEnabledFalse is false.
992      */
993     bool variableFalse = false;
994     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
995     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
996     ASSERT_FALSE(reportingEnabledFalse);
997     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
998     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_2 }, frameNode);
999     preTargetNode = dragDropManager->preTargetFrameNode_;
1000     ASSERT_TRUE(preTargetNode);
1001     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1002     ASSERT_TRUE(preTargetNode);
1003     ASSERT_FALSE(reportingEnabledFalse);
1004 }
1005 
1006 /**
1007  * @tc.name: DragDropReportTest015
1008  * @tc.desc: Test DragEventStrictReportingEnabled
1009  * @tc.type: FUNC
1010  * @tc.author:
1011  */
1012 HWTEST_F(DragDropReportTestNg, DragDropReportTest015, TestSize.Level1)
1013 {
1014     /**
1015      * @tc.steps: step1. construct a DragDropManager.
1016      * @tc.expected: dragDropManager is not null.
1017      */
1018     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1019     ASSERT_NE(dragDropManager, nullptr);
1020 
1021     /**
1022      * @tc.steps: step2. ReportingEnable is not set.
1023      * @tc.expected: reportingEnabledDefault is false.
1024      */
1025     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1026     ASSERT_FALSE(reportingEnabledDefault);
1027     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1028     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_3 }, frameNode);
1029     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1030     ASSERT_TRUE(preTargetNode);
1031     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1032     ASSERT_TRUE(preTargetNode);
1033     ASSERT_FALSE(reportingEnabledDefault);
1034     preTargetNode.Reset();
1035     frameNode.Reset();
1036 
1037     /**
1038      * @tc.steps: step3. ReportingSupported is set to true.
1039      * @tc.expected: reportingEnabledTrue is true.
1040      */
1041     bool variableTrue = true;
1042     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1043     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1044     ASSERT_TRUE(reportingEnabledTrue);
1045     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1046     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_3 }, frameNode);
1047     preTargetNode = dragDropManager->preTargetFrameNode_;
1048     ASSERT_TRUE(preTargetNode);
1049     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1050     ASSERT_TRUE(preTargetNode);
1051     ASSERT_TRUE(reportingEnabledTrue);
1052     preTargetNode.Reset();
1053     frameNode.Reset();
1054 
1055     /**
1056      * @tc.steps: step4. ReportingSupported is set to false.
1057      * @tc.expected: reportingEnabledFalse is false.
1058      */
1059     bool variableFalse = false;
1060     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1061     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1062     ASSERT_FALSE(reportingEnabledFalse);
1063     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1064     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_3 }, frameNode);
1065     preTargetNode = dragDropManager->preTargetFrameNode_;
1066     ASSERT_TRUE(preTargetNode);
1067     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1068     ASSERT_TRUE(preTargetNode);
1069     ASSERT_FALSE(reportingEnabledFalse);
1070 }
1071 
1072 /**
1073  * @tc.name: DragDropReportTest016
1074  * @tc.desc: Test DragEventStrictReportingEnabled
1075  * @tc.type: FUNC
1076  * @tc.author:
1077  */
1078 HWTEST_F(DragDropReportTestNg, DragDropReportTest016, TestSize.Level1)
1079 {
1080     /**
1081      * @tc.steps: step1. construct a DragDropManager.
1082      * @tc.expected: dragDropManager is not null.
1083      */
1084     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1085     ASSERT_NE(dragDropManager, nullptr);
1086 
1087     /**
1088      * @tc.steps: step2. ReportingEnable is not set.
1089      * @tc.expected: reportingEnabledDefault is false.
1090      */
1091     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1092     ASSERT_FALSE(reportingEnabledDefault);
1093     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1094     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
1095     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1096     ASSERT_TRUE(preTargetNode);
1097     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1098     ASSERT_TRUE(preTargetNode);
1099     ASSERT_FALSE(reportingEnabledDefault);
1100     preTargetNode.Reset();
1101     frameNode.Reset();
1102 
1103     /**
1104      * @tc.steps: step3. ReportingSupported is set to true.
1105      * @tc.expected: reportingEnabledTrue is true.
1106      */
1107     bool variableTrue = true;
1108     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1109     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1110     ASSERT_TRUE(reportingEnabledTrue);
1111     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1112     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
1113     preTargetNode = dragDropManager->preTargetFrameNode_;
1114     ASSERT_TRUE(preTargetNode);
1115     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1116     ASSERT_TRUE(preTargetNode);
1117     ASSERT_TRUE(reportingEnabledTrue);
1118     preTargetNode.Reset();
1119     frameNode.Reset();
1120 
1121     /**
1122      * @tc.steps: step4. ReportingSupported is set to false.
1123      * @tc.expected: reportingEnabledFalse is false.
1124      */
1125     bool variableFalse = false;
1126     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1127     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1128     ASSERT_FALSE(reportingEnabledFalse);
1129     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1130     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
1131     preTargetNode = dragDropManager->preTargetFrameNode_;
1132     ASSERT_TRUE(preTargetNode);
1133     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1134     ASSERT_TRUE(preTargetNode);
1135     ASSERT_FALSE(reportingEnabledFalse);
1136 }
1137 
1138 /**
1139  * @tc.name: DragDropReportTest017
1140  * @tc.desc: Test DragEventStrictReportingEnabled
1141  * @tc.type: FUNC
1142  * @tc.author:
1143  */
1144 HWTEST_F(DragDropReportTestNg, DragDropReportTest017, TestSize.Level1)
1145 {
1146     /**
1147      * @tc.steps: step1. construct a DragDropManager.
1148      * @tc.expected: dragDropManager is not null.
1149      */
1150     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1151     ASSERT_NE(dragDropManager, nullptr);
1152 
1153     /**
1154      * @tc.steps: step2. ReportingEnable is not set.
1155      * @tc.expected: reportingEnabledDefault is false.
1156      */
1157     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1158     ASSERT_FALSE(reportingEnabledDefault);
1159     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1160     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
1161     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1162     ASSERT_TRUE(preTargetNode);
1163     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1164     ASSERT_TRUE(preTargetNode);
1165     ASSERT_FALSE(reportingEnabledDefault);
1166     preTargetNode.Reset();
1167     frameNode.Reset();
1168 
1169     /**
1170      * @tc.steps: step3. ReportingSupported is set to true.
1171      * @tc.expected: reportingEnabledTrue is true.
1172      */
1173     bool variableTrue = true;
1174     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1175     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1176     ASSERT_TRUE(reportingEnabledTrue);
1177     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1178     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
1179     preTargetNode = dragDropManager->preTargetFrameNode_;
1180     ASSERT_TRUE(preTargetNode);
1181     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1182     ASSERT_TRUE(preTargetNode);
1183     ASSERT_TRUE(reportingEnabledTrue);
1184     preTargetNode.Reset();
1185     frameNode.Reset();
1186 
1187     /**
1188      * @tc.steps: step4. ReportingSupported is set to false.
1189      * @tc.expected: reportingEnabledFalse is false.
1190      */
1191     bool variableFalse = false;
1192     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1193     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1194     ASSERT_FALSE(reportingEnabledFalse);
1195     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1196     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
1197     preTargetNode = dragDropManager->preTargetFrameNode_;
1198     ASSERT_TRUE(preTargetNode);
1199     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1200     ASSERT_TRUE(preTargetNode);
1201     ASSERT_FALSE(reportingEnabledFalse);
1202     preTargetNode.Reset();
1203     frameNode.Reset();
1204 }
1205 
1206 /**
1207  * @tc.name: DragDropReportTest018
1208  * @tc.desc: Test DragEventStrictReportingEnabled
1209  * @tc.type: FUNC
1210  * @tc.author:
1211  */
1212 HWTEST_F(DragDropReportTestNg, DragDropReportTest018, TestSize.Level1)
1213 {
1214     /**
1215      * @tc.steps: step1. construct a DragDropManager.
1216      * @tc.expected: dragDropManager is not null.
1217      */
1218     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1219     ASSERT_NE(dragDropManager, nullptr);
1220 
1221     /**
1222      * @tc.steps: step2. ReportingEnable is not set.
1223      * @tc.expected: reportingEnabledDefault is false.
1224      */
1225     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1226     ASSERT_FALSE(reportingEnabledDefault);
1227     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1228     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_1 }, frameNode);
1229     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1230     ASSERT_TRUE(preTargetNode);
1231     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
1232     ASSERT_TRUE(preTargetNode);
1233     ASSERT_FALSE(reportingEnabledDefault);
1234     preTargetNode.Reset();
1235     frameNode.Reset();
1236 
1237     /**
1238      * @tc.steps: step3. ReportingSupported is set to true.
1239      * @tc.expected: reportingEnabledTrue is true.
1240      */
1241     bool variableTrue = true;
1242     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1243     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1244     ASSERT_TRUE(reportingEnabledTrue);
1245     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1246     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_1 }, frameNode);
1247     preTargetNode = dragDropManager->preTargetFrameNode_;
1248     ASSERT_TRUE(preTargetNode);
1249     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
1250     ASSERT_TRUE(preTargetNode);
1251     ASSERT_TRUE(reportingEnabledTrue);
1252     preTargetNode.Reset();
1253     frameNode.Reset();
1254 
1255     /**
1256      * @tc.steps: step4. ReportingSupported is set to false.
1257      * @tc.expected: reportingEnabledFalse is false.
1258      */
1259     bool variableFalse = false;
1260     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1261     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1262     ASSERT_FALSE(reportingEnabledFalse);
1263     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1264     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_1 }, frameNode);
1265     preTargetNode = dragDropManager->preTargetFrameNode_;
1266     ASSERT_TRUE(preTargetNode);
1267     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
1268     ASSERT_TRUE(preTargetNode);
1269     ASSERT_FALSE(reportingEnabledFalse);
1270 }
1271 
1272 /**
1273  * @tc.name: DragDropReportTest019
1274  * @tc.desc: Test DragEventStrictReportingEnabled
1275  * @tc.type: FUNC
1276  * @tc.author:
1277  */
1278 HWTEST_F(DragDropReportTestNg, DragDropReportTest019, TestSize.Level1)
1279 {
1280     /**
1281      * @tc.steps: step1. construct a DragDropManager.
1282      * @tc.expected: dragDropManager is not null.
1283      */
1284     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1285     ASSERT_NE(dragDropManager, nullptr);
1286 
1287     /**
1288      * @tc.steps: step2. ReportingEnable is not set.
1289      * @tc.expected: reportingEnabledDefault is false.
1290      */
1291     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1292     ASSERT_FALSE(reportingEnabledDefault);
1293     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1294     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1295     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1296     ASSERT_TRUE(preTargetNode);
1297     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
1298     ASSERT_TRUE(preTargetNode);
1299     ASSERT_FALSE(reportingEnabledDefault);
1300     preTargetNode.Reset();
1301     frameNode.Reset();
1302 
1303     /**
1304      * @tc.steps: step3. ReportingSupported is set to true.
1305      * @tc.expected: reportingEnabledTrue is true.
1306      */
1307     bool variableTrue = true;
1308     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1309     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1310     ASSERT_TRUE(reportingEnabledTrue);
1311     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1312     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1313     preTargetNode = dragDropManager->preTargetFrameNode_;
1314     ASSERT_TRUE(preTargetNode);
1315     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
1316     ASSERT_TRUE(preTargetNode);
1317     ASSERT_TRUE(reportingEnabledTrue);
1318     preTargetNode.Reset();
1319     frameNode.Reset();
1320 
1321     /**
1322      * @tc.steps: step4. ReportingSupported is set to false.
1323      * @tc.expected: reportingEnabledFalse is false.
1324      */
1325     bool variableFalse = false;
1326     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1327     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1328     ASSERT_FALSE(reportingEnabledFalse);
1329     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1330     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1331     preTargetNode = dragDropManager->preTargetFrameNode_;
1332     ASSERT_TRUE(preTargetNode);
1333     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
1334     ASSERT_TRUE(preTargetNode);
1335     ASSERT_FALSE(reportingEnabledFalse);
1336 }
1337 
1338 /**
1339  * @tc.name: DragDropReportTest020
1340  * @tc.desc: Test DragEventStrictReportingEnabled
1341  * @tc.type: FUNC
1342  * @tc.author:
1343  */
1344 HWTEST_F(DragDropReportTestNg, DragDropReportTest020, TestSize.Level1)
1345 {
1346     /**
1347      * @tc.steps: step1. construct a DragDropManager.
1348      * @tc.expected: dragDropManager is not null.
1349      */
1350     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1351     ASSERT_NE(dragDropManager, nullptr);
1352 
1353     /**
1354      * @tc.steps: step2. ReportingEnable is not set.
1355      * @tc.expected: reportingEnabledDefault is false.
1356      */
1357     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1358     ASSERT_FALSE(reportingEnabledDefault);
1359     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1360     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
1361     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1362     ASSERT_TRUE(preTargetNode);
1363     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1364     ASSERT_TRUE(preTargetNode);
1365     ASSERT_FALSE(reportingEnabledDefault);
1366     preTargetNode.Reset();
1367     frameNode.Reset();
1368 
1369     /**
1370      * @tc.steps: step3. ReportingSupported is set to true.
1371      * @tc.expected: reportingEnabledTrue is true.
1372      */
1373     bool variableTrue = true;
1374     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1375     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1376     ASSERT_TRUE(reportingEnabledTrue);
1377     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1378     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
1379     preTargetNode = dragDropManager->preTargetFrameNode_;
1380     ASSERT_TRUE(preTargetNode);
1381     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1382     ASSERT_TRUE(preTargetNode);
1383     ASSERT_TRUE(reportingEnabledTrue);
1384     preTargetNode.Reset();
1385     frameNode.Reset();
1386 
1387     /**
1388      * @tc.steps: step4. ReportingSupported is set to false.
1389      * @tc.expected: reportingEnabledFalse is false.
1390      */
1391     bool variableFalse = false;
1392     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1393     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1394     ASSERT_FALSE(reportingEnabledFalse);
1395     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1396     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
1397     preTargetNode = dragDropManager->preTargetFrameNode_;
1398     ASSERT_TRUE(preTargetNode);
1399     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1400     ASSERT_TRUE(preTargetNode);
1401     ASSERT_FALSE(reportingEnabledFalse);
1402 }
1403 
1404 /**
1405  * @tc.name: DragDropReportTest021
1406  * @tc.desc: Test DragEventStrictReportingEnabled
1407  * @tc.type: FUNC
1408  * @tc.author:
1409  */
1410 HWTEST_F(DragDropReportTestNg, DragDropReportTest021, TestSize.Level1)
1411 {
1412     /**
1413      * @tc.steps: step1. construct a DragDropManager.
1414      * @tc.expected: dragDropManager is not null.
1415      */
1416     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1417     ASSERT_NE(dragDropManager, nullptr);
1418 
1419     /**
1420      * @tc.steps: step2. ReportingEnable is not set.
1421      * @tc.expected: reportingEnabledDefault is false.
1422      */
1423     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1424     ASSERT_FALSE(reportingEnabledDefault);
1425     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1426     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1427     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1428     ASSERT_TRUE(preTargetNode);
1429     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1430     ASSERT_TRUE(preTargetNode);
1431     ASSERT_FALSE(reportingEnabledDefault);
1432     preTargetNode.Reset();
1433     frameNode.Reset();
1434 
1435     /**
1436      * @tc.steps: step3. ReportingSupported is set to true.
1437      * @tc.expected: reportingEnabledTrue is true.
1438      */
1439     bool variableTrue = true;
1440     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1441     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1442     ASSERT_TRUE(reportingEnabledTrue);
1443     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1444     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1445     preTargetNode = dragDropManager->preTargetFrameNode_;
1446     ASSERT_TRUE(preTargetNode);
1447     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1448     ASSERT_TRUE(preTargetNode);
1449     ASSERT_TRUE(reportingEnabledTrue);
1450     preTargetNode.Reset();
1451     frameNode.Reset();
1452 
1453     /**
1454      * @tc.steps: step4. ReportingSupported is set to false.
1455      * @tc.expected: reportingEnabledFalse is false.
1456      */
1457     bool variableFalse = false;
1458     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1459     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1460     ASSERT_FALSE(reportingEnabledFalse);
1461     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1462     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1463     preTargetNode = dragDropManager->preTargetFrameNode_;
1464     ASSERT_TRUE(preTargetNode);
1465     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
1466     ASSERT_TRUE(preTargetNode);
1467     ASSERT_FALSE(reportingEnabledFalse);
1468 }
1469 
1470 /**
1471  * @tc.name: DragDropReportTest022
1472  * @tc.desc: Test DragEventStrictReportingEnabled
1473  * @tc.type: FUNC
1474  * @tc.author:
1475  */
1476 HWTEST_F(DragDropReportTestNg, DragDropReportTest022, TestSize.Level1)
1477 {
1478     /**
1479      * @tc.steps: step1. construct a DragDropManager.
1480      * @tc.expected: dragDropManager is not null.
1481      */
1482     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1483     ASSERT_NE(dragDropManager, nullptr);
1484 
1485     /**
1486      * @tc.steps: step2. ReportingEnable is not set.
1487      * @tc.expected: reportingEnabledDefault is false.
1488      */
1489     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1490     ASSERT_FALSE(reportingEnabledDefault);
1491     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1492     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_1 }, frameNode);
1493     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1494     ASSERT_TRUE(preTargetNode);
1495     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
1496     ASSERT_TRUE(preTargetNode);
1497     ASSERT_FALSE(reportingEnabledDefault);
1498     preTargetNode.Reset();
1499     frameNode.Reset();
1500 
1501     /**
1502      * @tc.steps: step3. ReportingSupported is set to true.
1503      * @tc.expected: reportingEnabledTrue is true.
1504      */
1505     bool variableTrue = true;
1506     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1507     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1508     ASSERT_TRUE(reportingEnabledTrue);
1509     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1510     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_1 }, frameNode);
1511     preTargetNode = dragDropManager->preTargetFrameNode_;
1512     ASSERT_TRUE(preTargetNode);
1513     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
1514     ASSERT_TRUE(preTargetNode);
1515     ASSERT_TRUE(reportingEnabledTrue);
1516     preTargetNode.Reset();
1517     frameNode.Reset();
1518 
1519     /**
1520      * @tc.steps: step4. ReportingSupported is set to false.
1521      * @tc.expected: reportingEnabledFalse is false.
1522      */
1523     bool variableFalse = false;
1524     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1525     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1526     ASSERT_FALSE(reportingEnabledFalse);
1527     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1528     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_1 }, frameNode);
1529     preTargetNode = dragDropManager->preTargetFrameNode_;
1530     ASSERT_TRUE(preTargetNode);
1531     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
1532     ASSERT_TRUE(preTargetNode);
1533     ASSERT_FALSE(reportingEnabledFalse);
1534 }
1535 
1536 /**
1537  * @tc.name: DragDropReportTest023
1538  * @tc.desc: Test DragEventStrictReportingEnabled
1539  * @tc.type: FUNC
1540  * @tc.author:
1541  */
1542 HWTEST_F(DragDropReportTestNg, DragDropReportTest023, TestSize.Level1)
1543 {
1544     /**
1545      * @tc.steps: step1. construct a DragDropManager.
1546      * @tc.expected: dragDropManager is not null.
1547      */
1548     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1549     ASSERT_NE(dragDropManager, nullptr);
1550 
1551     /**
1552      * @tc.steps: step2. ReportingEnable is not set.
1553      * @tc.expected: reportingEnabledDefault is false.
1554      */
1555     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1556     ASSERT_FALSE(reportingEnabledDefault);
1557     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1558     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1559     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1560     ASSERT_TRUE(preTargetNode);
1561     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1562     ASSERT_TRUE(preTargetNode);
1563     ASSERT_FALSE(reportingEnabledDefault);
1564     preTargetNode.Reset();
1565     frameNode.Reset();
1566 
1567     /**
1568      * @tc.steps: step3. ReportingSupported is set to true.
1569      * @tc.expected: reportingEnabledTrue is true.
1570      */
1571     bool variableTrue = true;
1572     ASSERT_TRUE(variableTrue);
1573     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1574     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1575     ASSERT_TRUE(reportingEnabledTrue);
1576     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1577     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1578     preTargetNode = dragDropManager->preTargetFrameNode_;
1579     ASSERT_TRUE(preTargetNode);
1580     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1581     ASSERT_TRUE(preTargetNode);
1582     ASSERT_TRUE(reportingEnabledTrue);
1583     preTargetNode.Reset();
1584     frameNode.Reset();
1585 
1586     /**
1587      * @tc.steps: step4. ReportingSupported is set to false.
1588      * @tc.expected: reportingEnabledFalse is false.
1589      */
1590     bool variableFalse = false;
1591     ASSERT_FALSE(variableFalse);
1592     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1593     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1594     ASSERT_FALSE(reportingEnabledFalse);
1595     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1596     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1597     preTargetNode = dragDropManager->preTargetFrameNode_;
1598     ASSERT_TRUE(preTargetNode);
1599     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1600     ASSERT_TRUE(preTargetNode);
1601     ASSERT_FALSE(reportingEnabledFalse);
1602 }
1603 
1604 /**
1605  * @tc.name: DragDropReportTest024
1606  * @tc.desc: Test DragEventStrictReportingEnabled
1607  * @tc.type: FUNC
1608  * @tc.author:
1609  */
1610 HWTEST_F(DragDropReportTestNg, DragDropReportTest024, TestSize.Level1)
1611 {
1612     /**
1613      * @tc.steps: step1. construct a DragDropManager.
1614      * @tc.expected: dragDropManager is not null.
1615      */
1616     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1617     ASSERT_NE(dragDropManager, nullptr);
1618 
1619     /**
1620      * @tc.steps: step2. ReportingEnable is not set.
1621      * @tc.expected: reportingEnabledDefault is false.
1622      */
1623     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1624     ASSERT_FALSE(reportingEnabledDefault);
1625     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1626     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1627     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1628     ASSERT_TRUE(preTargetNode);
1629     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1630     ASSERT_TRUE(preTargetNode);
1631     ASSERT_FALSE(reportingEnabledDefault);
1632     preTargetNode.Reset();
1633     frameNode.Reset();
1634 
1635     /**
1636      * @tc.steps: step3. ReportingSupported is set to true.
1637      * @tc.expected: reportingEnabledTrue is true.
1638      */
1639     bool variableTrue = true;
1640     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1641     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1642     ASSERT_TRUE(reportingEnabledTrue);
1643     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1644     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1645     preTargetNode = dragDropManager->preTargetFrameNode_;
1646     ASSERT_TRUE(preTargetNode);
1647     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1648     ASSERT_TRUE(preTargetNode);
1649     ASSERT_TRUE(reportingEnabledTrue);
1650     preTargetNode.Reset();
1651     frameNode.Reset();
1652 
1653     /**
1654      * @tc.steps: step4. ReportingSupported is set to false.
1655      * @tc.expected: reportingEnabledFalse is false.
1656      */
1657     bool variableFalse = false;
1658     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1659     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1660     ASSERT_FALSE(reportingEnabledFalse);
1661     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1662     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1663     preTargetNode = dragDropManager->preTargetFrameNode_;
1664     ASSERT_TRUE(preTargetNode);
1665     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1666     ASSERT_TRUE(preTargetNode);
1667     ASSERT_FALSE(reportingEnabledFalse);
1668 }
1669 
1670 /**
1671  * @tc.name: DragDropReportTest025
1672  * @tc.desc: Test DragEventStrictReportingEnabled
1673  * @tc.type: FUNC
1674  * @tc.author:
1675  */
1676 HWTEST_F(DragDropReportTestNg, DragDropReportTest025, TestSize.Level1)
1677 {
1678     /**
1679      * @tc.steps: step1. construct a DragDropManager.
1680      * @tc.expected: dragDropManager is not null.
1681      */
1682     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1683     ASSERT_NE(dragDropManager, nullptr);
1684 
1685     /**
1686      * @tc.steps: step2. ReportingEnable is not set.
1687      * @tc.expected: reportingEnabledDefault is false.
1688      */
1689     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1690     ASSERT_FALSE(reportingEnabledDefault);
1691     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1692     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
1693     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1694     ASSERT_TRUE(preTargetNode);
1695     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1696     ASSERT_TRUE(preTargetNode);
1697     ASSERT_FALSE(reportingEnabledDefault);
1698     preTargetNode.Reset();
1699     frameNode.Reset();
1700 
1701     /**
1702      * @tc.steps: step3. ReportingSupported is set to true.
1703      * @tc.expected: reportingEnabledTrue is true.
1704      */
1705     bool variableTrue = true;
1706     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1707     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1708     ASSERT_TRUE(reportingEnabledTrue);
1709     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1710     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
1711     preTargetNode = dragDropManager->preTargetFrameNode_;
1712     ASSERT_TRUE(preTargetNode);
1713     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1714     ASSERT_TRUE(preTargetNode);
1715     ASSERT_TRUE(reportingEnabledTrue);
1716     preTargetNode.Reset();
1717     frameNode.Reset();
1718 
1719     /**
1720      * @tc.steps: step4. ReportingSupported is set to false.
1721      * @tc.expected: reportingEnabledFalse is false.
1722      */
1723     bool variableFalse = false;
1724     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1725     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1726     ASSERT_FALSE(reportingEnabledFalse);
1727     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1728     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_3 }, frameNode);
1729     preTargetNode = dragDropManager->preTargetFrameNode_;
1730     ASSERT_TRUE(preTargetNode);
1731     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1732     ASSERT_TRUE(preTargetNode);
1733     ASSERT_FALSE(reportingEnabledFalse);
1734 }
1735 
1736 /**
1737  * @tc.name: DragDropReportTest026
1738  * @tc.desc: Test DragEventStrictReportingEnabled
1739  * @tc.type: FUNC
1740  * @tc.author:
1741  */
1742 HWTEST_F(DragDropReportTestNg, DragDropReportTest026, TestSize.Level1)
1743 {
1744     /**
1745      * @tc.steps: step1. construct a DragDropManager.
1746      * @tc.expected: dragDropManager is not null.
1747      */
1748     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1749     ASSERT_NE(dragDropManager, nullptr);
1750 
1751     /**
1752      * @tc.steps: step2. ReportingEnable is not set.
1753      * @tc.expected: reportingEnabledDefault is false.
1754      */
1755     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1756     ASSERT_FALSE(reportingEnabledDefault);
1757     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1758     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1759     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1760     ASSERT_TRUE(preTargetNode);
1761     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
1762     ASSERT_TRUE(preTargetNode);
1763     ASSERT_FALSE(reportingEnabledDefault);
1764     preTargetNode.Reset();
1765     frameNode.Reset();
1766 
1767     /**
1768      * @tc.steps: step3. ReportingSupported is set to true.
1769      * @tc.expected: reportingEnabledTrue is true.
1770      */
1771     bool variableTrue = true;
1772     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1773     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1774     ASSERT_TRUE(reportingEnabledTrue);
1775     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1776     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1777     preTargetNode = dragDropManager->preTargetFrameNode_;
1778     ASSERT_TRUE(preTargetNode);
1779     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
1780     ASSERT_TRUE(preTargetNode);
1781     ASSERT_TRUE(reportingEnabledTrue);
1782     preTargetNode.Reset();
1783     frameNode.Reset();
1784 
1785     /**
1786      * @tc.steps: step4. ReportingSupported is set to false.
1787      * @tc.expected: reportingEnabledFalse is false.
1788      */
1789     bool variableFalse = false;
1790     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1791     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1792     ASSERT_FALSE(reportingEnabledFalse);
1793     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1794     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1795     preTargetNode = dragDropManager->preTargetFrameNode_;
1796     ASSERT_TRUE(preTargetNode);
1797     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_3 }, EXTRA_INFO);
1798     ASSERT_TRUE(preTargetNode);
1799     ASSERT_FALSE(reportingEnabledFalse);
1800 }
1801 
1802 /**
1803  * @tc.name: DragDropReportTest027
1804  * @tc.desc: Test DragEventStrictReportingEnabled
1805  * @tc.type: FUNC
1806  * @tc.author:
1807  */
1808 HWTEST_F(DragDropReportTestNg, DragDropReportTest027, TestSize.Level1)
1809 {
1810     /**
1811      * @tc.steps: step1. construct a DragDropManager.
1812      * @tc.expected: dragDropManager is not null.
1813      */
1814     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1815     ASSERT_NE(dragDropManager, nullptr);
1816 
1817     /**
1818      * @tc.steps: step2. ReportingEnable is not set.
1819      * @tc.expected: reportingEnabledDefault is false.
1820      */
1821     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1822     ASSERT_FALSE(reportingEnabledDefault);
1823     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1824     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1825     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1826     ASSERT_TRUE(preTargetNode);
1827     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
1828     ASSERT_TRUE(preTargetNode);
1829     ASSERT_FALSE(reportingEnabledDefault);
1830     preTargetNode.Reset();
1831     frameNode.Reset();
1832 
1833     /**
1834      * @tc.steps: step3. ReportingSupported is set to true.
1835      * @tc.expected: reportingEnabledTrue is true.
1836      */
1837     bool variableTrue = true;
1838     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1839     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1840     ASSERT_TRUE(reportingEnabledTrue);
1841     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1842     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1843     preTargetNode = dragDropManager->preTargetFrameNode_;
1844     ASSERT_TRUE(preTargetNode);
1845     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
1846     ASSERT_TRUE(preTargetNode);
1847     ASSERT_TRUE(reportingEnabledTrue);
1848     preTargetNode.Reset();
1849     frameNode.Reset();
1850 
1851     /**
1852      * @tc.steps: step4. ReportingSupported is set to false.
1853      * @tc.expected: reportingEnabledFalse is false.
1854      */
1855     bool variableFalse = false;
1856     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1857     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1858     ASSERT_FALSE(reportingEnabledFalse);
1859     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1860     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
1861     preTargetNode = dragDropManager->preTargetFrameNode_;
1862     ASSERT_TRUE(preTargetNode);
1863     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
1864     ASSERT_TRUE(preTargetNode);
1865     ASSERT_FALSE(reportingEnabledFalse);
1866 }
1867 
1868 /**
1869  * @tc.name: DragDropReportTest028
1870  * @tc.desc: Test DragEventStrictReportingEnabled
1871  * @tc.type: FUNC
1872  * @tc.author:
1873  */
1874 HWTEST_F(DragDropReportTestNg, DragDropReportTest028, TestSize.Level1)
1875 {
1876     /**
1877      * @tc.steps: step1. construct a DragDropManager.
1878      * @tc.expected: dragDropManager is not null.
1879      */
1880     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1881     ASSERT_NE(dragDropManager, nullptr);
1882 
1883     /**
1884      * @tc.steps: step2. ReportingEnable is not set.
1885      * @tc.expected: reportingEnabledDefault is false.
1886      */
1887     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1888     ASSERT_FALSE(reportingEnabledDefault);
1889     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1890     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1891     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1892     ASSERT_TRUE(preTargetNode);
1893     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1894     ASSERT_TRUE(preTargetNode);
1895     ASSERT_FALSE(reportingEnabledDefault);
1896     preTargetNode.Reset();
1897     frameNode.Reset();
1898 
1899     /**
1900      * @tc.steps: step3. ReportingSupported is set to true.
1901      * @tc.expected: reportingEnabledTrue is true.
1902      */
1903     bool variableTrue = true;
1904     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1905     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1906     ASSERT_TRUE(reportingEnabledTrue);
1907     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1908     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1909     preTargetNode = dragDropManager->preTargetFrameNode_;
1910     ASSERT_TRUE(preTargetNode);
1911     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1912     ASSERT_TRUE(preTargetNode);
1913     ASSERT_TRUE(reportingEnabledTrue);
1914     preTargetNode.Reset();
1915     frameNode.Reset();
1916 
1917     /**
1918      * @tc.steps: step4. ReportingSupported is set to false.
1919      * @tc.expected: reportingEnabledFalse is false.
1920      */
1921     bool variableFalse = false;
1922     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1923     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1924     ASSERT_FALSE(reportingEnabledFalse);
1925     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1926     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_2 }, frameNode);
1927     preTargetNode = dragDropManager->preTargetFrameNode_;
1928     ASSERT_TRUE(preTargetNode);
1929     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
1930     ASSERT_TRUE(preTargetNode);
1931     ASSERT_FALSE(reportingEnabledFalse);
1932 }
1933 
1934 /**
1935  * @tc.name: DragDropReportTest029
1936  * @tc.desc: Test DragEventStrictReportingEnabled
1937  * @tc.type: FUNC
1938  * @tc.author:
1939  */
1940 HWTEST_F(DragDropReportTestNg, DragDropReportTest029, TestSize.Level1)
1941 {
1942     /**
1943      * @tc.steps: step1. construct a DragDropManager.
1944      * @tc.expected: dragDropManager is not null.
1945      */
1946     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
1947     ASSERT_NE(dragDropManager, nullptr);
1948 
1949     /**
1950      * @tc.steps: step2. ReportingEnable is not set.
1951      * @tc.expected: reportingEnabledDefault is false.
1952      */
1953     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
1954     ASSERT_FALSE(reportingEnabledDefault);
1955     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1956     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
1957     auto preTargetNode = dragDropManager->preTargetFrameNode_;
1958     ASSERT_TRUE(preTargetNode);
1959     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
1960     ASSERT_TRUE(preTargetNode);
1961     ASSERT_FALSE(reportingEnabledDefault);
1962     preTargetNode.Reset();
1963     frameNode.Reset();
1964 
1965     /**
1966      * @tc.steps: step3. ReportingSupported is set to true.
1967      * @tc.expected: reportingEnabledTrue is true.
1968      */
1969     bool variableTrue = true;
1970     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
1971     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
1972     ASSERT_TRUE(reportingEnabledTrue);
1973     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1974     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
1975     preTargetNode = dragDropManager->preTargetFrameNode_;
1976     ASSERT_TRUE(preTargetNode);
1977     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
1978     ASSERT_TRUE(preTargetNode);
1979     ASSERT_TRUE(reportingEnabledTrue);
1980     preTargetNode.Reset();
1981     frameNode.Reset();
1982 
1983     /**
1984      * @tc.steps: step4. ReportingSupported is set to false.
1985      * @tc.expected: reportingEnabledFalse is false.
1986      */
1987     bool variableFalse = false;
1988     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
1989     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
1990     ASSERT_FALSE(reportingEnabledFalse);
1991     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
1992     dragDropManager->OnDragStart({ GLOBAL_1, GLOBAL_1 }, frameNode);
1993     preTargetNode = dragDropManager->preTargetFrameNode_;
1994     ASSERT_TRUE(preTargetNode);
1995     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
1996     ASSERT_TRUE(preTargetNode);
1997     ASSERT_FALSE(reportingEnabledFalse);
1998 }
1999 
2000 /**
2001  * @tc.name: DragDropReportTest030
2002  * @tc.desc: Test DragEventStrictReportingEnabled
2003  * @tc.type: FUNC
2004  * @tc.author:
2005  */
2006 HWTEST_F(DragDropReportTestNg, DragDropReportTest030, TestSize.Level1)
2007 {
2008     /**
2009      * @tc.steps: step1. construct a DragDropManager.
2010      * @tc.expected: dragDropManager is not null.
2011      */
2012     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2013     ASSERT_NE(dragDropManager, nullptr);
2014 
2015     /**
2016      * @tc.steps: step2. ReportingEnable is not set.
2017      * @tc.expected: reportingEnabledDefault is false.
2018      */
2019     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
2020     ASSERT_FALSE(reportingEnabledDefault);
2021     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2022     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
2023     auto preTargetNode = dragDropManager->preTargetFrameNode_;
2024     ASSERT_TRUE(preTargetNode);
2025     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
2026     ASSERT_TRUE(preTargetNode);
2027     ASSERT_FALSE(reportingEnabledDefault);
2028     preTargetNode.Reset();
2029     frameNode.Reset();
2030 
2031     /**
2032      * @tc.steps: step3. ReportingSupported is set to true.
2033      * @tc.expected: reportingEnabledTrue is true.
2034      */
2035     bool variableTrue = true;
2036     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
2037     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
2038     ASSERT_TRUE(reportingEnabledTrue);
2039     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2040     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
2041     preTargetNode = dragDropManager->preTargetFrameNode_;
2042     ASSERT_TRUE(preTargetNode);
2043     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
2044     ASSERT_TRUE(preTargetNode);
2045     ASSERT_TRUE(reportingEnabledTrue);
2046     preTargetNode.Reset();
2047     frameNode.Reset();
2048 
2049     /**
2050      * @tc.steps: step4. ReportingSupported is set to false.
2051      * @tc.expected: reportingEnabledFalse is false.
2052      */
2053     bool variableFalse = false;
2054     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
2055     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
2056     ASSERT_FALSE(reportingEnabledFalse);
2057     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2058     dragDropManager->OnDragStart({ GLOBAL_2, GLOBAL_1 }, frameNode);
2059     preTargetNode = dragDropManager->preTargetFrameNode_;
2060     ASSERT_TRUE(preTargetNode);
2061     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
2062     ASSERT_TRUE(preTargetNode);
2063     ASSERT_FALSE(reportingEnabledFalse);
2064 }
2065 
2066 /**
2067  * @tc.name: DragDropReportTest031
2068  * @tc.desc: Test DragEventStrictReportingEnabled
2069  * @tc.type: FUNC
2070  * @tc.author:
2071  */
2072 HWTEST_F(DragDropReportTestNg, DragDropReportTest031, TestSize.Level1)
2073 {
2074     /**
2075      * @tc.steps: step1. construct a DragDropManager.
2076      * @tc.expected: dragDropManager is not null.
2077      */
2078     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2079     ASSERT_NE(dragDropManager, nullptr);
2080 
2081     /**
2082      * @tc.steps: step2. ReportingEnable is not set.
2083      * @tc.expected: reportingEnabledDefault is false.
2084      */
2085     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
2086     ASSERT_FALSE(reportingEnabledDefault);
2087     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2088     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
2089     auto preTargetNode = dragDropManager->preTargetFrameNode_;
2090     ASSERT_TRUE(preTargetNode);
2091     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
2092     ASSERT_TRUE(preTargetNode);
2093     ASSERT_FALSE(reportingEnabledDefault);
2094     preTargetNode.Reset();
2095     frameNode.Reset();
2096 
2097     /**
2098      * @tc.steps: step3. ReportingSupported is set to true.
2099      * @tc.expected: reportingEnabledTrue is true.
2100      */
2101     bool variableTrue = true;
2102     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
2103     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
2104     ASSERT_TRUE(reportingEnabledTrue);
2105     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2106     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
2107     preTargetNode = dragDropManager->preTargetFrameNode_;
2108     ASSERT_TRUE(preTargetNode);
2109     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
2110     ASSERT_TRUE(preTargetNode);
2111     ASSERT_TRUE(reportingEnabledTrue);
2112     preTargetNode.Reset();
2113     frameNode.Reset();
2114 
2115     /**
2116      * @tc.steps: step4. ReportingSupported is set to false.
2117      * @tc.expected: reportingEnabledFalse is false.
2118      */
2119     bool variableFalse = false;
2120     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
2121     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
2122     ASSERT_FALSE(reportingEnabledFalse);
2123     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2124     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_2 }, frameNode);
2125     preTargetNode = dragDropManager->preTargetFrameNode_;
2126     ASSERT_TRUE(preTargetNode);
2127     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_3 }, EXTRA_INFO);
2128     ASSERT_TRUE(preTargetNode);
2129     ASSERT_FALSE(reportingEnabledFalse);
2130 }
2131 
2132 /**
2133  * @tc.name: DragDropReportTest032
2134  * @tc.desc: Test DragEventStrictReportingEnabled
2135  * @tc.type: FUNC
2136  * @tc.author:
2137  */
2138 HWTEST_F(DragDropReportTestNg, DragDropReportTest032, TestSize.Level1)
2139 {
2140     /**
2141      * @tc.steps: step1. construct a DragDropManager.
2142      * @tc.expected: dragDropManager is not null.
2143      */
2144     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2145     ASSERT_NE(dragDropManager, nullptr);
2146 
2147     /**
2148      * @tc.steps: step2. ReportingEnable is not set.
2149      * @tc.expected: reportingEnabledDefault is false.
2150      */
2151     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
2152     ASSERT_FALSE(reportingEnabledDefault);
2153     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2154     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2155     auto preTargetNode = dragDropManager->preTargetFrameNode_;
2156     ASSERT_TRUE(preTargetNode);
2157     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
2158     ASSERT_TRUE(preTargetNode);
2159     ASSERT_FALSE(reportingEnabledDefault);
2160     preTargetNode.Reset();
2161     frameNode.Reset();
2162 
2163     /**
2164      * @tc.steps: step3. ReportingSupported is set to true.
2165      * @tc.expected: reportingEnabledTrue is true.
2166      */
2167     bool variableTrue = true;
2168     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
2169     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
2170     ASSERT_TRUE(reportingEnabledTrue);
2171     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2172     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2173     preTargetNode = dragDropManager->preTargetFrameNode_;
2174     ASSERT_TRUE(preTargetNode);
2175     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
2176     ASSERT_TRUE(preTargetNode);
2177     ASSERT_TRUE(reportingEnabledTrue);
2178     preTargetNode.Reset();
2179     frameNode.Reset();
2180 
2181     /**
2182      * @tc.steps: step4. ReportingSupported is set to false.
2183      * @tc.expected: reportingEnabledFalse is false.
2184      */
2185     bool variableFalse = false;
2186     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
2187     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
2188     ASSERT_FALSE(reportingEnabledFalse);
2189     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2190     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2191     preTargetNode = dragDropManager->preTargetFrameNode_;
2192     ASSERT_TRUE(preTargetNode);
2193     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_2 }, EXTRA_INFO);
2194     ASSERT_TRUE(preTargetNode);
2195     ASSERT_FALSE(reportingEnabledFalse);
2196 }
2197 
2198 /**
2199  * @tc.name: DragDropReportTest033
2200  * @tc.desc: Test DragEventStrictReportingEnabled
2201  * @tc.type: FUNC
2202  * @tc.author:
2203  */
2204 HWTEST_F(DragDropReportTestNg, DragDropReportTest033, TestSize.Level1)
2205 {
2206     /**
2207      * @tc.steps: step1. construct a DragDropManager.
2208      * @tc.expected: dragDropManager is not null.
2209      */
2210     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2211     ASSERT_NE(dragDropManager, nullptr);
2212 
2213     /**
2214      * @tc.steps: step2. ReportingEnable is not set.
2215      * @tc.expected: reportingEnabledDefault is false.
2216      */
2217     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
2218     ASSERT_FALSE(reportingEnabledDefault);
2219     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2220     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2221     auto preTargetNode = dragDropManager->preTargetFrameNode_;
2222     ASSERT_TRUE(preTargetNode);
2223     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
2224     ASSERT_TRUE(preTargetNode);
2225     ASSERT_FALSE(reportingEnabledDefault);
2226     preTargetNode.Reset();
2227     frameNode.Reset();
2228 
2229     /**
2230      * @tc.steps: step3. ReportingSupported is set to true.
2231      * @tc.expected: reportingEnabledTrue is true.
2232      */
2233     bool variableTrue = true;
2234     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
2235     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
2236     ASSERT_TRUE(reportingEnabledTrue);
2237     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2238     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2239     preTargetNode = dragDropManager->preTargetFrameNode_;
2240     ASSERT_TRUE(preTargetNode);
2241     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
2242     ASSERT_TRUE(preTargetNode);
2243     ASSERT_TRUE(reportingEnabledTrue);
2244     preTargetNode.Reset();
2245     frameNode.Reset();
2246 
2247     /**
2248      * @tc.steps: step4. ReportingSupported is set to false.
2249      * @tc.expected: reportingEnabledFalse is false.
2250      */
2251     bool variableFalse = false;
2252     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
2253     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
2254     ASSERT_FALSE(reportingEnabledFalse);
2255     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2256     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2257     preTargetNode = dragDropManager->preTargetFrameNode_;
2258     ASSERT_TRUE(preTargetNode);
2259     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_2 }, EXTRA_INFO);
2260     ASSERT_TRUE(preTargetNode);
2261     ASSERT_FALSE(reportingEnabledFalse);
2262 }
2263 
2264 /**
2265  * @tc.name: DragDropReportTest034
2266  * @tc.desc: Test DragEventStrictReportingEnabled
2267  * @tc.type: FUNC
2268  * @tc.author:
2269  */
2270 HWTEST_F(DragDropReportTestNg, DragDropReportTest034, TestSize.Level1)
2271 {
2272     /**
2273      * @tc.steps: step1. construct a DragDropManager.
2274      * @tc.expected: dragDropManager is not null.
2275      */
2276     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2277     ASSERT_NE(dragDropManager, nullptr);
2278 
2279     /**
2280      * @tc.steps: step2. ReportingEnable is not set.
2281      * @tc.expected: reportingEnabledDefault is false.
2282      */
2283     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
2284     ASSERT_FALSE(reportingEnabledDefault);
2285     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2286     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2287     auto preTargetNode = dragDropManager->preTargetFrameNode_;
2288     ASSERT_TRUE(preTargetNode);
2289     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
2290     ASSERT_TRUE(preTargetNode);
2291     ASSERT_FALSE(reportingEnabledDefault);
2292     preTargetNode.Reset();
2293     frameNode.Reset();
2294 
2295     /**
2296      * @tc.steps: step3. ReportingSupported is set to true.
2297      * @tc.expected: reportingEnabledTrue is true.
2298      */
2299     bool variableTrue = true;
2300     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
2301     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
2302     ASSERT_TRUE(reportingEnabledTrue);
2303     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2304     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2305     preTargetNode = dragDropManager->preTargetFrameNode_;
2306     ASSERT_TRUE(preTargetNode);
2307     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
2308     ASSERT_TRUE(preTargetNode);
2309     ASSERT_TRUE(reportingEnabledTrue);
2310     preTargetNode.Reset();
2311     frameNode.Reset();
2312 
2313     /**
2314      * @tc.steps: step4. ReportingSupported is set to false.
2315      * @tc.expected: reportingEnabledFalse is false.
2316      */
2317     bool variableFalse = false;
2318     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
2319     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
2320     ASSERT_FALSE(reportingEnabledFalse);
2321     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2322     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2323     preTargetNode = dragDropManager->preTargetFrameNode_;
2324     ASSERT_TRUE(preTargetNode);
2325     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_2, GLOBAL_1 }, EXTRA_INFO);
2326     ASSERT_TRUE(preTargetNode);
2327     ASSERT_FALSE(reportingEnabledFalse);
2328 }
2329 
2330 /**
2331  * @tc.name: DragDropReportTest035
2332  * @tc.desc: Test DragEventStrictReportingEnabled
2333  * @tc.type: FUNC
2334  * @tc.author:
2335  */
2336 HWTEST_F(DragDropReportTestNg, DragDropReportTest035, TestSize.Level1)
2337 {
2338     /**
2339      * @tc.steps: step1. construct a DragDropManager.
2340      * @tc.expected: dragDropManager is not null.
2341      */
2342     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2343     ASSERT_NE(dragDropManager, nullptr);
2344 
2345     /**
2346      * @tc.steps: step2. ReportingEnable is not set.
2347      * @tc.expected: reportingEnabledDefault is false.
2348      */
2349     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
2350     ASSERT_FALSE(reportingEnabledDefault);
2351     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2352     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2353     auto preTargetNode = dragDropManager->preTargetFrameNode_;
2354     ASSERT_TRUE(preTargetNode);
2355     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
2356     ASSERT_TRUE(preTargetNode);
2357     ASSERT_FALSE(reportingEnabledDefault);
2358     preTargetNode.Reset();
2359     frameNode.Reset();
2360 
2361     /**
2362      * @tc.steps: step3. ReportingSupported is set to true.
2363      * @tc.expected: reportingEnabledTrue is true.
2364      */
2365     bool variableTrue = true;
2366     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
2367     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
2368     ASSERT_TRUE(reportingEnabledTrue);
2369     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2370     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2371     preTargetNode = dragDropManager->preTargetFrameNode_;
2372     ASSERT_TRUE(preTargetNode);
2373     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
2374     ASSERT_TRUE(preTargetNode);
2375     ASSERT_TRUE(reportingEnabledTrue);
2376     preTargetNode.Reset();
2377     frameNode.Reset();
2378 
2379     /**
2380      * @tc.steps: step4. ReportingSupported is set to false.
2381      * @tc.expected: reportingEnabledFalse is false.
2382      */
2383     bool variableFalse = false;
2384     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
2385     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
2386     ASSERT_FALSE(reportingEnabledFalse);
2387     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2388     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2389     preTargetNode = dragDropManager->preTargetFrameNode_;
2390     ASSERT_TRUE(preTargetNode);
2391     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_3, GLOBAL_1 }, EXTRA_INFO);
2392     ASSERT_TRUE(preTargetNode);
2393     ASSERT_FALSE(reportingEnabledFalse);
2394 }
2395 
2396 /**
2397  * @tc.name: DragDropReportTest036
2398  * @tc.desc: Test DragEventStrictReportingEnabled
2399  * @tc.type: FUNC
2400  * @tc.author:
2401  */
2402 HWTEST_F(DragDropReportTestNg, DragDropReportTest036, TestSize.Level1)
2403 {
2404     /**
2405      * @tc.steps: step1. construct a DragDropManager.
2406      * @tc.expected: dragDropManager is not null.
2407      */
2408     auto dragDropManager = AceType::MakeRefPtr<DragDropManager>();
2409     ASSERT_NE(dragDropManager, nullptr);
2410 
2411     /**
2412      * @tc.steps: step2. ReportingEnable is not set.
2413      * @tc.expected: reportingEnabledDefault is false.
2414      */
2415     bool reportingEnabledDefault = dragDropManager->IsEventStrictReportingEnabled();
2416     ASSERT_FALSE(reportingEnabledDefault);
2417     auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2418     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2419     auto preTargetNode = dragDropManager->preTargetFrameNode_;
2420     ASSERT_TRUE(preTargetNode);
2421     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
2422     ASSERT_TRUE(preTargetNode);
2423     ASSERT_FALSE(reportingEnabledDefault);
2424     preTargetNode.Reset();
2425     frameNode.Reset();
2426 
2427     /**
2428      * @tc.steps: step3. ReportingSupported is set to true.
2429      * @tc.expected: reportingEnabledTrue is true.
2430      */
2431     bool variableTrue = true;
2432     dragDropManager->SetEventStrictReportingEnabled(variableTrue);
2433     bool reportingEnabledTrue = dragDropManager->IsEventStrictReportingEnabled();
2434     ASSERT_TRUE(reportingEnabledTrue);
2435     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2436     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2437     preTargetNode = dragDropManager->preTargetFrameNode_;
2438     ASSERT_TRUE(preTargetNode);
2439     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
2440     ASSERT_TRUE(preTargetNode);
2441     ASSERT_TRUE(reportingEnabledTrue);
2442     preTargetNode.Reset();
2443     frameNode.Reset();
2444 
2445     /**
2446      * @tc.steps: step4. ReportingSupported is set to false.
2447      * @tc.expected: reportingEnabledFalse is false.
2448      */
2449     bool variableFalse = false;
2450     dragDropManager->SetEventStrictReportingEnabled(variableFalse);
2451     bool reportingEnabledFalse = dragDropManager->IsEventStrictReportingEnabled();
2452     ASSERT_FALSE(reportingEnabledFalse);
2453     frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
2454     dragDropManager->OnDragStart({ GLOBAL_3, GLOBAL_3 }, frameNode);
2455     preTargetNode = dragDropManager->preTargetFrameNode_;
2456     ASSERT_TRUE(preTargetNode);
2457     dragDropManager->FireOnDragLeave(preTargetNode, { GLOBAL_1, GLOBAL_3 }, EXTRA_INFO);
2458     ASSERT_TRUE(preTargetNode);
2459     ASSERT_FALSE(reportingEnabledFalse);
2460 }
2461 } // namespace OHOS::Ace::NG