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 #define private public
20 #define protected public
21 
22 #include "test/mock/base/mock_task_executor.h"
23 #include "test/mock/core/common/mock_container.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/size_t.h"
28 #include "base/memory/ace_type.h"
29 #include "base/memory/referenced.h"
30 #include "core/components_ng/base/frame_node.h"
31 #include "core/components_ng/base/geometry_node.h"
32 #include "core/components_ng/manager/select_content_overlay/select_overlay_callback.h"
33 #include "core/components_ng/manager/select_content_overlay/select_overlay_holder.h"
34 #include "core/components_ng/manager/select_overlay/select_overlay_manager.h"
35 #include "core/components_ng/pattern/pattern.h"
36 #include "core/components_ng/pattern/select_overlay/select_overlay_pattern.h"
37 #include "core/components_ng/pattern/select_overlay/select_overlay_property.h"
38 #include "core/components_ng/pattern/text/text_base.h"
39 #include "core/components_ng/pattern/text/text_pattern.h"
40 #include "core/components_ng/pattern/text_field/text_field_pattern.h"
41 #include "core/components_ng/property/property.h"
42 
43 using namespace testing;
44 using namespace testing::ext;
45 
46 namespace OHOS::Ace::NG {
47 namespace {
48 const std::string ROOT_TAG("root");
49 constexpr int32_t NODE_ID = 143;
50 constexpr int32_t NODE_ID_2 = 601;
51 constexpr int32_t NODE_ID_3 = 707;
52 const OffsetF RIGHT_CLICK_OFFSET = OffsetF(10.0f, 10.0f);
53 const OffsetF ROOT_OFFSET = OffsetF(10.0f, 10.0f);
54 const bool IS_USING_MOUSE = true;
55 } // namespace
56 
57 class SelectOverlayManagerTestNg : public testing::Test {
58 public:
59     static void SetUpTestSuite();
60     static void TearDownTestSuite();
61     RefPtr<SelectOverlayManager> selectOverlayManager_;
62     RefPtr<SelectOverlayProxy> proxy_;
63     RefPtr<FrameNode> root_;
64     void Init();
65 };
66 
67 class MockSelectOverlayHolder : public SelectOverlayHolder, public SelectOverlayCallback {
68     DECLARE_ACE_TYPE(MockSelectOverlayHolder, SelectOverlayHolder, SelectOverlayCallback);
69 
70 public:
71     MockSelectOverlayHolder() = default;
72     ~MockSelectOverlayHolder() = default;
73 
SetOwner(const RefPtr<FrameNode> & node)74     void SetOwner(const RefPtr<FrameNode>& node)
75     {
76         node_ = node;
77     }
78 
GetOwner()79     RefPtr<FrameNode> GetOwner()
80     {
81         return node_;
82     }
83 
GetCallback()84     RefPtr<SelectOverlayCallback> GetCallback() override
85     {
86         return Claim(this);
87     }
88 
OnUpdateSelectOverlayInfo(SelectOverlayInfo & overlayInfo,int32_t requestCode)89     void OnUpdateSelectOverlayInfo(SelectOverlayInfo& overlayInfo, int32_t requestCode)
90     {
91         overlayInfo.enableHandleLevel = true;
92         overlayInfo.handleLevelMode = handleLevelMode_;
93         overlayInfo.menuInfo.menuIsShow = true;
94     }
95 
OnHandleLevelModeChanged(HandleLevelMode mode)96     void OnHandleLevelModeChanged(HandleLevelMode mode) override
97     {
98         handleLevelMode_ = mode;
99     }
100 
CheckSwitchToMode(HandleLevelMode mode)101     bool CheckSwitchToMode(HandleLevelMode mode) override
102     {
103         return allowSwitchMode_;
104     }
105 
CheckTouchInHostNode(const PointF & touchPoint)106     bool CheckTouchInHostNode(const PointF& touchPoint)
107     {
108         return false;
109     }
110 
111 private:
112     HandleLevelMode handleLevelMode_ = HandleLevelMode::OVERLAY;
113     bool allowSwitchMode_ = false;
114     RefPtr<FrameNode> node_;
115 };
116 
SetUpTestSuite()117 void SelectOverlayManagerTestNg::SetUpTestSuite()
118 {
119     MockPipelineContext::SetUp();
120     MockContainer::SetUp();
121     MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
122 }
123 
TearDownTestSuite()124 void SelectOverlayManagerTestNg::TearDownTestSuite()
125 {
126     MockPipelineContext::TearDown();
127     MockContainer::TearDown();
128 }
129 
Init()130 void SelectOverlayManagerTestNg::Init()
131 {
132     SelectOverlayInfo selectOverlayInfo;
133     selectOverlayInfo.singleLineHeight = NODE_ID;
134     root_ = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
135     selectOverlayManager_ = AceType::MakeRefPtr<SelectOverlayManager>(root_);
136     ASSERT_NE(selectOverlayManager_, nullptr);
137     proxy_ = selectOverlayManager_->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
138     ASSERT_NE(proxy_, nullptr);
139 }
140 /**
141  * @tc.name: SelectOverlayManagerTest001
142  * @tc.desc: test first CreateAndShowSelectOverlay
143  * @tc.type: FUNC
144  */
145 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest001, TestSize.Level1)
146 {
147     /**
148      * @tc.steps: step1. call CreateAndShowSelectOverlay
149      * @tc.expected: return the proxy which has the right SelectOverlayId
150      */
151     Init();
152     auto id = proxy_->GetSelectOverlayId();
153     EXPECT_EQ(id, 2);
154 
155     /**
156      * @tc.expected: root's children_list contains the selectOverlayNode we created
157      */
158     auto selectOverlayNode = root_->GetChildren().back();
159     ASSERT_TRUE(selectOverlayNode);
160     auto node_id = selectOverlayNode->GetId();
161     EXPECT_EQ(node_id, 2);
162 }
163 
164 /**
165  * @tc.name: SelectOverlayManagerTest002
166  * @tc.desc: test DestroySelectOverlay(proxy) successfully
167  * @tc.type: FUNC
168  */
169 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest002, TestSize.Level1)
170 {
171     /**
172      * @tc.steps: step1. construct a SelectOverlayManager and call CreateAndShowSelectOverlay
173      */
174     SelectOverlayInfo selectOverlayInfo;
175     selectOverlayInfo.singleLineHeight = NODE_ID;
176     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
177     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
178     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
179 
180     /**
181      * @tc.expected: root's children_list contains the selectOverlayNode we created
182      */
183     auto selectOverlayNode = root->GetChildren().back();
184     ASSERT_TRUE(selectOverlayNode);
185     auto node_id = selectOverlayManager->selectOverlayInfo_.singleLineHeight;
186     EXPECT_EQ(node_id, NODE_ID);
187 
188     /**
189      * @tc.steps: step2. call DestroySelectOverlay
190      * @tc.expected: root's children_list has removed the selectOverlayNode we created
191      */
192     selectOverlayManager->DestroySelectOverlay(proxy);
193     auto children = root->GetChildren();
194     EXPECT_TRUE(children.empty());
195 }
196 
197 /**
198  * @tc.name: SelectOverlayManagerTest003
199  * @tc.desc: test CreateAndShowSelectOverlay while the selectOverlayItem_ has existed
200  * @tc.type: FUNC
201  */
202 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest003, TestSize.Level1)
203 {
204     /**
205      * @tc.steps: step1. construct a SelectOverlayManager and call CreateAndShowSelectOverlay
206      * @tc.expected: return the proxy which has the right SelectOverlayId
207      */
208     SelectOverlayInfo selectOverlayInfo;
209     selectOverlayInfo.singleLineHeight = NODE_ID;
210     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
211     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
212     auto textFrameNode =
__anon2e703efe0202() 213         FrameNode::GetOrCreateFrameNode(V2::TEXT_ETS_TAG, 10, []() { return AceType::MakeRefPtr<TextPattern>(); });
214     ASSERT_TRUE(textFrameNode);
215     auto textPattern = textFrameNode->GetPattern<TextPattern>();
216     ASSERT_TRUE(textPattern);
217     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, textPattern);
218     ASSERT_TRUE(proxy);
219     auto id = selectOverlayManager->selectOverlayInfo_.singleLineHeight;
220     EXPECT_EQ(id, NODE_ID);
221     selectOverlayManager->DestroySelectOverlay(34);
222 
223     /**
224      * @tc.steps: step2. call CreateAndShowSelectOverlay again and change the param
225      * @tc.expected: return the proxy which has the right SelectOverlayId
226      */
227     SelectOverlayInfo selectOverlayInfo2;
228     selectOverlayInfo2.singleLineHeight = NODE_ID_2;
229     auto proxy2 = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo2, textPattern);
230     ASSERT_TRUE(proxy2);
231     auto id2 = selectOverlayManager->selectOverlayInfo_.singleLineHeight;
232     EXPECT_EQ(id2, NODE_ID_2);
233 
234     /**
235      * @tc.steps: step3. call CreateAndShowSelectOverlay again and change the param
236      * @tc.expected: return the proxy which has the right SelectOverlayId
237      */
238     SelectOverlayInfo selectOverlayInfo3;
239     selectOverlayInfo3.singleLineHeight = NODE_ID_3;
240     auto proxy3 = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo3, textPattern);
241     ASSERT_TRUE(proxy3);
242     auto id3 = selectOverlayManager->selectOverlayInfo_.singleLineHeight;
243     EXPECT_EQ(id3, NODE_ID_3);
244 }
245 
246 /**
247  * @tc.name: SelectOverlayManagerTest004
248  * @tc.desc: test DestroySelectOverlay fail
249  * @tc.type: FUNC
250  */
251 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest004, TestSize.Level1)
252 {
253     /**
254      * @tc.steps: step1. construct a SelectOverlayManager and call CreateAndShowSelectOverlay
255      * @tc.expected: return the proxy which has the right SelectOverlayId
256      */
257     SelectOverlayInfo selectOverlayInfo;
258     selectOverlayInfo.singleLineHeight = NODE_ID;
259     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
260     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
261     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
262     ASSERT_TRUE(proxy);
263     auto id = selectOverlayManager->selectOverlayInfo_.singleLineHeight;
264     EXPECT_EQ(id, NODE_ID);
265 
266     /**
267      * @tc.steps: step2. call DestroySelectOverlay with wrong param
268      * @tc.expected: destroySelectOverlay fail and the proxy still has the original SelectOverlayId
269      */
270     selectOverlayManager->DestroySelectOverlay(NODE_ID_2);
271     auto children = root->GetChildren();
272     EXPECT_FALSE(children.empty());
273     id = selectOverlayManager->selectOverlayInfo_.singleLineHeight;
274     EXPECT_EQ(id, NODE_ID);
275 }
276 
277 /**
278  * @tc.name: SelectOverlayManagerTest005
279  * @tc.desc: test HasSelectOverlay
280  * @tc.type: FUNC
281  */
282 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest005, TestSize.Level1)
283 {
284     /**
285      * @tc.steps: step1. construct a SelectOverlayManager and call CreateAndShowSelectOverlay
286      * @tc.expected: return the proxy which has the right SelectOverlayId
287      */
288     SelectOverlayInfo selectOverlayInfo;
289     selectOverlayInfo.singleLineHeight = NODE_ID;
290     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
291     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
292     selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
293 
294     /**
295      * @tc.steps: step2. call HasSelectOverlay with the param of existed SelectOverlayId
296      * @tc.expected: return true
297      */
298     auto flag1 = selectOverlayManager->HasSelectOverlay(NODE_ID);
299     EXPECT_FALSE(flag1);
300 
301     /**
302      * @tc.steps: step3. call HasSelectOverlay with the param of existed SelectOverlayId
303      * @tc.expected: return false
304      */
305     auto flag2 = selectOverlayManager->HasSelectOverlay(NODE_ID_2);
306     EXPECT_FALSE(flag2);
307 }
308 
309 /**
310  * @tc.name: SelectOverlayManagerTest006
311  * @tc.desc: test GetSelectOverlayNode
312  * @tc.type: FUNC
313  */
314 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest006, TestSize.Level1)
315 {
316     /**
317      * @tc.steps: step1. construct a SelectOverlayManager
318      */
319     SelectOverlayInfo selectOverlayInfo;
320     selectOverlayInfo.singleLineHeight = NODE_ID;
321     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
322     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
323 
324     /**
325      * @tc.steps: step2. call GetSelectOverlayNode without calling CreateAndShowSelectOverlay
326      * @tc.expected: return nullptr
327      */
328     auto node1 = selectOverlayManager->GetSelectOverlayNode(NODE_ID);
329     EXPECT_FALSE(node1);
330 
331     /**
332      * @tc.steps: step3. call CreateAndShowSelectOverlay
333      */
334     selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
335 
336     /**
337      * @tc.steps: step4. call GetSelectOverlayNode with right overlayId
338      * @tc.expected: return the selectOverlayNode with right nodeId
339      */
340     auto node2 = selectOverlayManager->GetSelectOverlayNode(NODE_ID);
341 
342     /**
343      * @tc.steps: step5. call GetSelectOverlayNode with wrong overlayId
344      * @tc.expected: return nullptr
345      */
346     auto node3 = selectOverlayManager->GetSelectOverlayNode(NODE_ID_2);
347     EXPECT_FALSE(node3);
348 }
349 
350 /**
351  * @tc.name: SelectOverlayManagerTest007
352  * @tc.desc: test IsSameSelectOverlayInfo
353  * @tc.type: FUNC
354  */
355 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest007, TestSize.Level1)
356 {
357     /**
358      * @tc.steps: step1. construct a SelectOverlayManager
359      */
360     SelectOverlayInfo selectOverlayInfo;
361     selectOverlayInfo.singleLineHeight = NODE_ID;
362     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
363     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
364 
365     /**
366      * @tc.steps: step2. change menuInfo and call IsSameSelectOverlayInfo with different selectOverlayInfo
367      * @tc.expected: return false
368      */
369     SelectOverlayInfo selectOverlayInfo2;
370     SelectMenuInfo selectMenuInfo2;
371     selectMenuInfo2.showCopy = false;
372     selectOverlayInfo2.menuInfo = selectMenuInfo2;
373     auto flag1 = selectOverlayManager->IsSameSelectOverlayInfo(selectOverlayInfo2);
374     EXPECT_FALSE(flag1);
375 
376     /**
377      * @tc.steps: step3. change isUsingMouse and call IsSameSelectOverlayInfo with different selectOverlayInfo
378      * @tc.expected: return false
379      */
380     SelectOverlayInfo selectOverlayInfo3;
381     selectOverlayInfo3.isUsingMouse = IS_USING_MOUSE;
382     auto flag2 = selectOverlayManager->IsSameSelectOverlayInfo(selectOverlayInfo3);
383     EXPECT_FALSE(flag2);
384 
385     /**
386      * @tc.steps: step4. change rightClickOffset and call IsSameSelectOverlayInfo with different selectOverlayInfo
387      * @tc.expected: return false
388      */
389     SelectOverlayInfo selectOverlayInfo4;
390     selectOverlayInfo4.rightClickOffset = RIGHT_CLICK_OFFSET;
391     auto flag3 = selectOverlayManager->IsSameSelectOverlayInfo(selectOverlayInfo4);
392     EXPECT_FALSE(flag3);
393 
394     /**
395      * @tc.steps: step5. call IsSameSelectOverlayInfo with right selectOverlayInfo
396      * @tc.expected: return true
397      */
398     auto flag = selectOverlayManager->IsSameSelectOverlayInfo(selectOverlayInfo);
399     EXPECT_TRUE(flag);
400 }
401 
402 /**
403  * @tc.name: SelectOverlayManagerTest008
404  * @tc.desc: test DestroySelectOverlay
405  * @tc.type: FUNC
406  */
407 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest008, TestSize.Level1)
408 {
409     /**
410      * @tc.steps: step1. construct a SelectOverlayManager and call CreateAndShowSelectOverlay
411      */
412     SelectOverlayInfo selectOverlayInfo;
413     selectOverlayInfo.singleLineHeight = NODE_ID;
414     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
415     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
416     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
417     ASSERT_TRUE(proxy);
418 
419     /**
420      * @tc.expected: root's children_list contains the selectOverlayNode we created
421      */
422     auto selectOverlayNode = root->GetChildren().back();
423     ASSERT_TRUE(selectOverlayNode);
424     auto node_id = selectOverlayManager->selectOverlayInfo_.singleLineHeight;
425     EXPECT_EQ(node_id, NODE_ID);
426 
427     /**
428      * @tc.steps: step2. call DestroySelectOverlay
429      * @tc.expected: root's children_list has removed the selectOverlayNode we created
430      */
431     selectOverlayManager->DestroySelectOverlay();
432     auto children = root->GetChildren();
433     EXPECT_TRUE(children.empty());
434     /**
435      * @tc.steps: step3. call DestroySelectOverlay again when current node is invalid
436      * @tc.expected: function exits normally
437      */
438     PropertyChangeFlag flag = PROPERTY_UPDATE_NORMAL;
439     selectOverlayManager->MarkDirty(flag);
440     TouchEvent touchPoint;
441     selectOverlayManager->HandleGlobalEvent(touchPoint, ROOT_OFFSET);
442     selectOverlayManager->NotifyOverlayClosed();
443     selectOverlayManager->DestroySelectOverlay(NODE_ID);
444     EXPECT_TRUE(children.empty());
445 }
446 
447 /**
448  * @tc.name: SelectOverlayManagerTest009
449  * @tc.desc: test IsInSelectedOrSelectOverlayArea
450  * @tc.type: FUNC
451  */
452 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest009, TestSize.Level1)
453 {
454     /**
455      * @tc.steps: step1. construct a SelectOverlayManager and call CreateAndShowSelectOverlay
456      */
457     SelectOverlayInfo selectOverlayInfo;
458     selectOverlayInfo.singleLineHeight = NODE_ID;
459     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
460     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
461     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
462 
463     /**
464      * @tc.expected: root's children_list contains the selectOverlayNode we created
465      */
466     auto selectOverlayNode = root->GetChildren().back();
467     ASSERT_TRUE(selectOverlayNode);
468     auto node_id = selectOverlayManager->selectOverlayInfo_.singleLineHeight;
469     EXPECT_EQ(node_id, NODE_ID);
470 
471     /**
472      * @tc.steps: step2. call IsInSelectedOrSelectOverlayArea
473      * @tc.expected: return true
474      */
475     PropertyChangeFlag flag = PROPERTY_UPDATE_NORMAL;
476     selectOverlayManager->MarkDirty(flag);
477     const NG::PointF point { 0.0f, 0.0f };
478     auto result = selectOverlayManager->IsInSelectedOrSelectOverlayArea(point);
479     EXPECT_FALSE(result);
480 }
481 /**
482  * @tc.name: SelectOverlayManagerTest010
483  * @tc.desc: test IsTouchInCallerArea
484  * @tc.type: FUNC
485  */
486 HWTEST_F(SelectOverlayManagerTestNg, SelectOverlayManagerTest010, TestSize.Level1)
487 {
488     /**
489      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
490      * @tc.expected: return false
491      */
492     Init();
493     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
494     EXPECT_FALSE(result1);
495     /**
496      * @tc.steps: step2. call HandleGlobalEvent
497      */
498     TouchEvent touchPoint;
499     selectOverlayManager_->HandleGlobalEvent(touchPoint, ROOT_OFFSET);
500     /**
501      * @tc.steps: step3. call DestroySelectOverlay with animation
502      * @tc.expected: root's children_list has removed the selectOverlayNode we created
503      */
504     selectOverlayManager_->DestroySelectOverlay(true);
505     auto children = root_->GetChildren();
506     EXPECT_TRUE(children.empty());
507 }
508 
509 /**
510  * @tc.name: FindWindowScene001
511  * @tc.desc: test FindWindowScene
512  * @tc.type: FUNC
513  */
514 HWTEST_F(SelectOverlayManagerTestNg, FindWindowScene001, TestSize.Level1)
515 {
516     /**
517      * @tc.steps: step1. construct a SelectOverlayManager
518      */
519     SelectOverlayInfo selectOverlayInfo;
520     selectOverlayInfo.singleLineHeight = NODE_ID;
521     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
522     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
523     /**
524      * @tc.steps: step2. call FindWindowScene
525      */
526     auto rootNode = selectOverlayManager->FindWindowScene(nullptr);
527     EXPECT_TRUE(rootNode);
528 }
529 
530 /**
531  * @tc.name: HandleGlobalEvent01
532  * @tc.desc: test HandleGlobalEvent
533  * @tc.type: FUNC
534  */
535 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent01, TestSize.Level1)
536 {
537     /**
538      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
539      * @tc.expected: return false
540      */
541     Init();
542     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
543     EXPECT_FALSE(result1);
544     /**
545      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
546      */
547     TouchEvent touchPoint;
548     touchPoint.type = TouchType::DOWN;
549     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
550     EXPECT_NE(touchPoint.sourceType, SourceType::TOUCH);
551     /**
552      * @tc.steps: step3. call DestroySelectOverlay with animation
553      * @tc.expected: root's children_list has removed the selectOverlayNode we created
554      */
555     selectOverlayManager_->DestroySelectOverlay(true);
556     auto children = root_->GetChildren();
557     EXPECT_TRUE(children.empty());
558 }
559 
560 /**
561  * @tc.name: HandleGlobalEvent02
562  * @tc.desc: test HandleGlobalEvent
563  * @tc.type: FUNC
564  */
565 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent02, TestSize.Level1)
566 {
567     /**
568      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
569      * @tc.expected: return false
570      */
571     Init();
572     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
573     EXPECT_FALSE(result1);
574     /**
575      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
576      */
577     TouchEvent touchPoint;
578     touchPoint.sourceType = SourceType::TOUCH;
579     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
580     EXPECT_NE(touchPoint.type, TouchType::DOWN);
581     /**
582      * @tc.steps: step3. call DestroySelectOverlay with animation
583      * @tc.expected: root's children_list has removed the selectOverlayNode we created
584      */
585     selectOverlayManager_->DestroySelectOverlay(true);
586     auto children = root_->GetChildren();
587     EXPECT_TRUE(children.empty());
588 }
589 
590 /**
591  * @tc.name: HandleGlobalEvent03
592  * @tc.desc: test HandleGlobalEvent
593  * @tc.type: FUNC
594  */
595 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent03, TestSize.Level1)
596 {
597     /**
598      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
599      * @tc.expected: return false
600      */
601     Init();
602     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
603     EXPECT_FALSE(result1);
604     /**
605      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
606      */
607     TouchEvent touchPoint;
608     touchPoint.type = TouchType::MOVE;
609     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
610     EXPECT_NE(touchPoint.sourceType, SourceType::TOUCH);
611     /**
612      * @tc.steps: step3. call DestroySelectOverlay with animation
613      * @tc.expected: root's children_list has removed the selectOverlayNode we created
614      */
615     selectOverlayManager_->DestroySelectOverlay(true);
616     auto children = root_->GetChildren();
617     EXPECT_TRUE(children.empty());
618 }
619 
620 /**
621  * @tc.name: HandleGlobalEvent04
622  * @tc.desc: test HandleGlobalEvent
623  * @tc.type: FUNC
624  */
625 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent04, TestSize.Level1)
626 {
627     /**
628      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
629      * @tc.expected: return false
630      */
631     Init();
632     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
633     EXPECT_FALSE(result1);
634     /**
635      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
636      */
637     TouchEvent touchPoint;
638     touchPoint.type = TouchType::MOVE;
639     touchPoint.sourceType = SourceType::TOUCH;
640     selectOverlayManager_->touchDownPoints_.emplace_back(touchPoint);
641     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
642     EXPECT_NE(touchPoint.sourceType, SourceType::MOUSE);
643     /**
644      * @tc.steps: step3. call DestroySelectOverlay with animation
645      * @tc.expected: root's children_list has removed the selectOverlayNode we created
646      */
647     selectOverlayManager_->DestroySelectOverlay(true);
648     auto children = root_->GetChildren();
649     EXPECT_TRUE(children.empty());
650 }
651 
652 /**
653  * @tc.name: HandleGlobalEvent05
654  * @tc.desc: test HandleGlobalEvent
655  * @tc.type: FUNC
656  */
657 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent05, TestSize.Level1)
658 {
659     /**
660      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
661      * @tc.expected: return false
662      */
663     Init();
664     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
665     EXPECT_FALSE(result1);
666     /**
667      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
668      */
669     TouchEvent touchPoint;
670     TouchEvent touchPointerror;
671     touchPointerror.id = 5;
672     touchPointerror.x = 5;
673     touchPointerror.y = 5;
674     touchPoint.type = TouchType::MOVE;
675     touchPoint.sourceType = SourceType::TOUCH;
676     selectOverlayManager_->touchDownPoints_.emplace_back(touchPointerror);
677     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
678     EXPECT_NE(touchPoint.sourceType, SourceType::MOUSE);
679     /**
680      * @tc.steps: step3. call DestroySelectOverlay with animation
681      * @tc.expected: root's children_list has removed the selectOverlayNode we created
682      */
683     selectOverlayManager_->DestroySelectOverlay(true);
684     auto children = root_->GetChildren();
685     EXPECT_TRUE(children.empty());
686 }
687 
688 /**
689  * @tc.name: HandleGlobalEvent06
690  * @tc.desc: test HandleGlobalEvent
691  * @tc.type: FUNC
692  */
693 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent06, TestSize.Level1)
694 {
695     /**
696      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
697      * @tc.expected: return false
698      */
699     Init();
700     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
701     EXPECT_FALSE(result1);
702     /**
703      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
704      */
705     TouchEvent touchPoint;
706     TouchEvent touchPointerror;
707     touchPointerror.id = 5;
708     touchPoint.type = TouchType::MOVE;
709     touchPoint.sourceType = SourceType::TOUCH;
710     selectOverlayManager_->touchDownPoints_.emplace_back(touchPointerror);
711     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
712     EXPECT_NE(touchPoint.sourceType, SourceType::MOUSE);
713     /**
714      * @tc.steps: step3. call DestroySelectOverlay with animation
715      * @tc.expected: root's children_list has removed the selectOverlayNode we created
716      */
717     selectOverlayManager_->DestroySelectOverlay(true);
718     auto children = root_->GetChildren();
719     EXPECT_TRUE(children.empty());
720 }
721 
722 /**
723  * @tc.name: HandleGlobalEvent07
724  * @tc.desc: test HandleGlobalEvent
725  * @tc.type: FUNC
726  */
727 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent07, TestSize.Level1)
728 {
729     /**
730      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
731      * @tc.expected: return false
732      */
733     Init();
734     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
735     EXPECT_FALSE(result1);
736     /**
737      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
738      */
739     TouchEvent touchPoint;
740     touchPoint.type = TouchType::DOWN;
741     touchPoint.sourceType = SourceType::TOUCH;
742     selectOverlayManager_->touchDownPoints_.emplace_back(touchPoint);
743     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
744     EXPECT_NE(touchPoint.sourceType, SourceType::MOUSE);
745     /**
746      * @tc.steps: step3. call DestroySelectOverlay with animation
747      * @tc.expected: root's children_list has removed the selectOverlayNode we created
748      */
749     selectOverlayManager_->DestroySelectOverlay(true);
750     auto children = root_->GetChildren();
751     EXPECT_TRUE(children.empty());
752 }
753 
754 /**
755  * @tc.name: HandleGlobalEvent08
756  * @tc.desc: test HandleGlobalEvent
757  * @tc.type: FUNC
758  */
759 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent08, TestSize.Level1)
760 {
761     /**
762      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
763      * @tc.expected: return false
764      */
765     Init();
766     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
767     EXPECT_FALSE(result1);
768     /**
769      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
770      */
771     TouchEvent touchPoint;
772     touchPoint.type = TouchType::DOWN;
773     touchPoint.sourceType = SourceType::TOUCH;
774     selectOverlayManager_->touchDownPoints_.clear();
775     touchPoint.x = 1.1f;
776     touchPoint.y = 1.1f;
777     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
778     EXPECT_NE(touchPoint.sourceType, SourceType::MOUSE);
779     /**
780      * @tc.steps: step3. call DestroySelectOverlay with animation
781      * @tc.expected: root's children_list has removed the selectOverlayNode we created
782      */
783     selectOverlayManager_->DestroySelectOverlay(true);
784     auto children = root_->GetChildren();
785     EXPECT_TRUE(children.empty());
786 }
787 
788 /**
789  * @tc.name: HandleGlobalEvent09
790  * @tc.desc: test HandleGlobalEvent
791  * @tc.type: FUNC
792  */
793 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent09, TestSize.Level1)
794 {
795     /**
796      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
797      * @tc.expected: return false
798      */
799     Init();
800     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
801     EXPECT_FALSE(result1);
802     /**
803      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
804      */
805     TouchEvent touchPoint;
806     touchPoint.type = TouchType::DOWN;
807     touchPoint.sourceType = SourceType::TOUCH;
808     selectOverlayManager_->touchDownPoints_.clear();
809     auto selectOverlayNode = root_->GetChildren().back();
810     auto id = std::to_string(selectOverlayNode->GetId());
811     selectOverlayManager_->touchTestResults_.emplace_back(id);
812     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
813     EXPECT_NE(touchPoint.sourceType, SourceType::MOUSE);
814     /**
815      * @tc.steps: step3. call DestroySelectOverlay with animation
816      * @tc.expected: root's children_list has removed the selectOverlayNode we created
817      */
818     selectOverlayManager_->DestroySelectOverlay(true);
819     auto children = root_->GetChildren();
820     EXPECT_TRUE(children.empty());
821 }
822 
823 /**
824  * @tc.name: HandleGlobalEvent10
825  * @tc.desc: test HandleGlobalEvent
826  * @tc.type: FUNC
827  */
828 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent10, TestSize.Level1)
829 {
830     /**
831      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
832      * @tc.expected: return false
833      */
834     Init();
835     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
836     EXPECT_FALSE(result1);
837     /**
838      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
839      */
840     TouchEvent touchPoint;
841     TouchEvent touchPointerror;
842     touchPoint.type = TouchType::MOVE;
843     touchPoint.sourceType = SourceType::TOUCH;
844     selectOverlayManager_->touchDownPoints_.clear();
845     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
846     EXPECT_NE(touchPoint.sourceType, SourceType::MOUSE);
847     /**
848      * @tc.steps: step3. call DestroySelectOverlay with animation
849      * @tc.expected: root's children_list has removed the selectOverlayNode we created
850      */
851     selectOverlayManager_->DestroySelectOverlay(true);
852     auto children = root_->GetChildren();
853     EXPECT_TRUE(children.empty());
854 }
855 
856 /**
857  * @tc.name: HandleGlobalEvent11
858  * @tc.desc: test HandleGlobalEvent
859  * @tc.type: FUNC
860  */
861 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent11, TestSize.Level1)
862 {
863     /**
864      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
865      * @tc.expected: return false
866      */
867     Init();
868     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
869     EXPECT_FALSE(result1);
870     /**
871      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
872      */
873     TouchEvent touchPoint;
874     touchPoint.type = TouchType::UP;
875     touchPoint.sourceType = SourceType::TOUCH;
876     selectOverlayManager_->touchDownPoints_.emplace_back(touchPoint);
877     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
878     EXPECT_TRUE(selectOverlayManager_->touchDownPoints_.empty());
879     /**
880      * @tc.steps: step3. call DestroySelectOverlay with animation
881      * @tc.expected: root's children_list has removed the selectOverlayNode we created
882      */
883     selectOverlayManager_->DestroySelectOverlay(true);
884     auto children = root_->GetChildren();
885     EXPECT_TRUE(children.empty());
886 }
887 
888 /**
889  * @tc.name: HandleGlobalEvent12
890  * @tc.desc: test HandleGlobalEvent
891  * @tc.type: FUNC
892  */
893 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent12, TestSize.Level1)
894 {
895     /**
896      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
897      * @tc.expected: return false
898      */
899     Init();
900     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
901     EXPECT_FALSE(result1);
902     /**
903      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
904      */
905     TouchEvent touchPoint;
906     touchPoint.type = TouchType::DOWN;
907     touchPoint.sourceType = SourceType::MOUSE;
908     touchPoint.x = 1.1f;
909     touchPoint.y = 1.1f;
910     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
911     EXPECT_NE(touchPoint.sourceType, SourceType::TOUCH);
912     /**
913      * @tc.steps: step3. call DestroySelectOverlay with animation
914      * @tc.expected: root's children_list has removed the selectOverlayNode we created
915      */
916     selectOverlayManager_->DestroySelectOverlay(true);
917     auto children = root_->GetChildren();
918     EXPECT_TRUE(children.empty());
919 }
920 
921 /**
922  * @tc.name: HandleGlobalEvent13
923  * @tc.desc: test HandleGlobalEvent
924  * @tc.type: FUNC
925  */
926 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent13, TestSize.Level1)
927 {
928     /**
929      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
930      * @tc.expected: return false
931      */
932     Init();
933     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
934     EXPECT_FALSE(result1);
935     /**
936      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
937      */
938     TouchEvent touchPoint;
939     touchPoint.type = TouchType::UP;
940     touchPoint.sourceType = SourceType::TOUCH;
941     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
942     EXPECT_TRUE(selectOverlayManager_->touchDownPoints_.empty());
943     /**
944      * @tc.steps: step3. call DestroySelectOverlay with animation
945      * @tc.expected: root's children_list has removed the selectOverlayNode we created
946      */
947     selectOverlayManager_->DestroySelectOverlay(true);
948     auto children = root_->GetChildren();
949     EXPECT_TRUE(children.empty());
950 }
951 
952 /**
953  * @tc.name: HandleGlobalEvent14
954  * @tc.desc: test HandleGlobalEvent
955  * @tc.type: FUNC
956  */
957 HWTEST_F(SelectOverlayManagerTestNg, HandleGlobalEvent14, TestSize.Level1)
958 {
959     /**
960      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is empty
961      * @tc.expected: return false
962      */
963     Init();
964     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
965     EXPECT_FALSE(result1);
966     /**
967      * @tc.steps: step2. Change the properties of the TouchEvent and call HandleGlobalEvent
968      */
969     TouchEvent touchPoint;
970     TouchEvent touchPointerror;
971     touchPointerror.id = 5;
972     touchPoint.type = TouchType::UP;
973     touchPoint.sourceType = SourceType::TOUCH;
974     selectOverlayManager_->touchDownPoints_.emplace_back(touchPointerror);
975     selectOverlayManager_->HandleGlobalEvent(touchPoint, OffsetF(0.0f, 0.0f));
976     EXPECT_FALSE(selectOverlayManager_->touchDownPoints_.empty());
977     /**
978      * @tc.steps: step3. call DestroySelectOverlay with animation
979      * @tc.expected: root's children_list has removed the selectOverlayNode we created
980      */
981     selectOverlayManager_->DestroySelectOverlay(true);
982     auto children = root_->GetChildren();
983     EXPECT_TRUE(children.empty());
984 }
985 
986 /**
987  * @tc.name: IsTouchInCallerArea01
988  * @tc.desc: test NotifyOverlayClosed and IsTouchInCallerArea
989  * @tc.type: FUNC
990  */
991 HWTEST_F(SelectOverlayManagerTestNg, IsTouchInCallerArea01, TestSize.Level1)
992 {
993     /**
994      * @tc.steps: step1. call IsTouchInCallerArea when touchTestResults_ is !empty
995      * @tc.expected: return true
996      */
997     Init();
998     SelectOverlayInfo selectOverlayInfo;
999     selectOverlayInfo.singleLineHeight = NODE_ID;
1000     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
1001     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
1002     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
1003     auto selectOverlayNode = root_->GetChildren().back();
1004     auto id = std::to_string(selectOverlayNode->GetId());
1005     selectOverlayManager_->touchTestResults_.emplace_back(id);
1006     auto result1 = selectOverlayManager_->IsTouchInCallerArea();
1007     /**
1008      * @tc.steps: step2. call NotifyOverlayClosed
1009      */
1010     selectOverlayManager->NotifyOverlayClosed(true);
1011     EXPECT_FALSE(result1);
1012 }
1013 
1014 /**
1015  * @tc.name: NotifyOnScrollCallback01
1016  * @tc.desc: test NotifyOnScrollCallback and RemoveScrollCallback
1017  * @tc.type: FUNC
1018  */
1019 HWTEST_F(SelectOverlayManagerTestNg, NotifyOnScrollCallback01, TestSize.Level1)
1020 {
1021     /**
1022      * @tc.steps: step1. call CreateAndShowSelectOverlay
1023      * @tc.expected: return true
1024      */
1025     Init();
1026     SelectOverlayInfo selectOverlayInfo;
1027     selectOverlayInfo.singleLineHeight = NODE_ID;
1028     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
1029     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
1030     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
1031     EXPECT_TRUE(proxy);
1032     /**
1033      * @tc.steps: step2. call NotifyOnScrollCallback and RemoveScrollCallback
1034      * @tc.expected: return true
1035      */
1036     selectOverlayManager->NotifyOnScrollCallback(5, Axis::VERTICAL, 0.0, 0);
1037     selectOverlayManager->RemoveScrollCallback(9);
1038     EXPECT_TRUE(selectOverlayManager->parentScrollCallbacks_.empty());
1039 }
1040 
1041 /**
1042  * @tc.name: NotifyOnScrollCallback02
1043  * @tc.desc: test NotifyOnScrollCallback
1044  * @tc.type: FUNC
1045  */
1046 HWTEST_F(SelectOverlayManagerTestNg, NotifyOnScrollCallback02, TestSize.Level1)
1047 {
1048     /**
1049      * @tc.steps: step1. call CreateAndShowSelectOverlay
1050      * @tc.expected: return true
1051      */
1052     Init();
1053     SelectOverlayInfo selectOverlayInfo;
1054     selectOverlayInfo.singleLineHeight = NODE_ID;
1055     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
1056     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
1057     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
1058     EXPECT_TRUE(proxy);
1059     /**
1060      * @tc.steps: step2. Init func ScrollableParentCallback and insert toparentScrollCallbacks_
1061      */
__anon2e703efe0302(Axis axis, float value, int32_t id) 1062     ScrollableParentCallback callback = [&](Axis axis, float value, int32_t id) {
1063         axis = Axis::HORIZONTAL;
1064         value = 0.0;
1065         id = 5;
1066     };
1067     selectOverlayManager->RegisterScrollCallback(5, 5, std::move(callback));
1068     /**
1069      * @tc.steps: step3. call NotifyOnScrollCallback
1070      * @tc.expected: return false
1071      */
1072     selectOverlayManager->NotifyOnScrollCallback(5, Axis::VERTICAL, 0.0, 0);
1073     EXPECT_FALSE(selectOverlayManager->parentScrollCallbacks_.empty());
1074 }
1075 
1076 /**
1077  * @tc.name: NotifyOnScrollCallback03
1078  * @tc.desc: test NotifyOnScrollCallback
1079  * @tc.type: FUNC
1080  */
1081 HWTEST_F(SelectOverlayManagerTestNg, NotifyOnScrollCallback03, TestSize.Level1)
1082 {
1083     /**
1084      * @tc.steps: step1. call CreateAndShowSelectOverlay
1085      * @tc.expected: return true
1086      */
1087     Init();
1088     SelectOverlayInfo selectOverlayInfo;
1089     selectOverlayInfo.singleLineHeight = NODE_ID;
1090     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
1091     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
1092     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
1093     EXPECT_TRUE(proxy);
1094     /**
1095      * @tc.steps: step2. Init func ScrollableParentCallback and insert toparentScrollCallbacks_
1096      */
__anon2e703efe0402(Axis axis, float value, int32_t id) 1097     ScrollableParentCallback callback = [&](Axis axis, float value, int32_t id) {
1098         axis = Axis::HORIZONTAL;
1099         value = 0.0;
1100         id = 5;
1101     };
1102     selectOverlayManager->RegisterScrollCallback(0, 5, std::move(callback));
1103     /**
1104      * @tc.steps: step3. call NotifyOnScrollCallback
1105      * @tc.expected: return false
1106      */
1107     selectOverlayManager->NotifyOnScrollCallback(5, Axis::VERTICAL, 0.0, 0);
1108     EXPECT_FALSE(selectOverlayManager->parentScrollCallbacks_.empty());
1109 }
1110 
1111 /**
1112  * @tc.name: RemoveScrollCallback01
1113  * @tc.desc: test RemoveScrollCallback
1114  * @tc.type: FUNC
1115  */
1116 HWTEST_F(SelectOverlayManagerTestNg, RemoveScrollCallback01, TestSize.Level1)
1117 {
1118     /**
1119      * @tc.steps: step1. call CreateAndShowSelectOverlay
1120      * @tc.expected: return true
1121      */
1122     Init();
1123     SelectOverlayInfo selectOverlayInfo;
1124     selectOverlayInfo.singleLineHeight = NODE_ID;
1125     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
1126     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
1127     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
1128     EXPECT_TRUE(proxy);
1129     /**
1130      * @tc.steps: step2. Init func ScrollableParentCallback and insert toparentScrollCallbacks_
1131      */
__anon2e703efe0502(Axis axis, float value, int32_t id) 1132     ScrollableParentCallback callback = [&](Axis axis, float value, int32_t id) {
1133         axis = Axis::HORIZONTAL;
1134         value = 0.0;
1135         id = 5;
1136     };
1137     selectOverlayManager->RegisterScrollCallback(5, 5, std::move(callback));
1138     /**
1139      * @tc.steps: step3. call RemoveScrollCallback
1140      * @tc.expected: return true
1141      */
1142     selectOverlayManager->RemoveScrollCallback(5);
1143     EXPECT_TRUE(selectOverlayManager->parentScrollCallbacks_.empty());
1144 }
1145 
1146 /**
1147  * @tc.name: RemoveScrollCallback02
1148  * @tc.desc: test RemoveScrollCallback
1149  * @tc.type: FUNC
1150  */
1151 HWTEST_F(SelectOverlayManagerTestNg, RemoveScrollCallback02, TestSize.Level1)
1152 {
1153     /**
1154      * @tc.steps: step1. call CreateAndShowSelectOverlay
1155      * @tc.expected: return true
1156      */
1157     Init();
1158     SelectOverlayInfo selectOverlayInfo;
1159     selectOverlayInfo.singleLineHeight = NODE_ID;
1160     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
1161     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
1162     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
1163     EXPECT_TRUE(proxy);
1164     /**
1165      * @tc.steps: step2. Init func ScrollableParentCallback and insert toparentScrollCallbacks_
1166      */
__anon2e703efe0602(Axis axis, float value, int32_t id) 1167     ScrollableParentCallback callback = [&](Axis axis, float value, int32_t id) {
1168         axis = Axis::HORIZONTAL;
1169         value = 0.0;
1170         id = 5;
1171     };
1172     selectOverlayManager->RegisterScrollCallback(5, 5, std::move(callback));
1173     /**
1174      * @tc.steps: step3. call RemoveScrollCallback
1175      * @tc.expected: return false
1176      */
1177     selectOverlayManager->RemoveScrollCallback(0);
1178     EXPECT_FALSE(selectOverlayManager->parentScrollCallbacks_.empty());
1179 }
1180 
1181 /**
1182  * @tc.name: RemoveScrollCallback03
1183  * @tc.desc: test RemoveScrollCallback
1184  * @tc.type: FUNC
1185  */
1186 HWTEST_F(SelectOverlayManagerTestNg, RemoveScrollCallback03, TestSize.Level1)
1187 {
1188     /**
1189      * @tc.steps: step1. call CreateAndShowSelectOverlay
1190      * @tc.expected: return true
1191      */
1192     Init();
1193     SelectOverlayInfo selectOverlayInfo;
1194     selectOverlayInfo.singleLineHeight = NODE_ID;
1195     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
1196     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(root);
1197     auto proxy = selectOverlayManager->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
1198     EXPECT_TRUE(proxy);
1199     /**
1200      * @tc.steps: step2. Init func ScrollableParentCallback and insert toparentScrollCallbacks_
1201      */
__anon2e703efe0702(Axis axis, float value, int32_t id) 1202     ScrollableParentCallback callback = [&](Axis axis, float value, int32_t id) {
1203         axis = Axis::HORIZONTAL;
1204         value = 0.0;
1205         id = 5;
1206     };
1207     selectOverlayManager->RegisterScrollCallback(5, 5, std::move(callback));
1208     selectOverlayManager->RegisterScrollCallback(8, 5, std::move(callback));
1209     /**
1210      * @tc.steps: step3. call RemoveScrollCallback
1211      * @tc.expected: return false
1212      */
1213     selectOverlayManager->RemoveScrollCallback(9);
1214     EXPECT_FALSE(selectOverlayManager->parentScrollCallbacks_.empty());
1215 }
1216 
1217 /**
1218  * @tc.name: UpdateShowingSelectOverlay01
1219  * @tc.desc: test UpdateShowingSelectOverlay
1220  * @tc.type: FUNC
1221  */
1222 HWTEST_F(SelectOverlayManagerTestNg, UpdateShowingSelectOverlay01, TestSize.Level1)
1223 {
1224     /**
1225      * @tc.steps: step1. Init client and clientInfo
1226      */
1227     TextFieldPattern client;
1228     ClientOverlayInfo clientInfo;
1229     SelectHandleInfo handleInfo;
1230     SelectHandleInfo secondInfo;
1231     secondInfo.isShow = false;
1232     clientInfo.isShowMouseMenu = false;
1233     clientInfo.firstHandleInfo = handleInfo;
1234     clientInfo.secondHandleInfo = secondInfo;
1235 
1236     /**
1237      * @tc.steps: step2.call UpdateShowingSelectOverlay
1238      * @tc.expected: isUpdateMenu is true
1239      */
1240     client.UpdateShowingSelectOverlay(clientInfo);
1241     EXPECT_TRUE(clientInfo.isUpdateMenu);
1242 }
1243 
1244 /**
1245  * @tc.name: UpdateShowingSelectOverlay02
1246  * @tc.desc: test UpdateShowingSelectOverlay
1247  * @tc.type: FUNC
1248  */
1249 HWTEST_F(SelectOverlayManagerTestNg, UpdateShowingSelectOverlay02, TestSize.Level1)
1250 {
1251     /**
1252      * @tc.steps: step1. Init client and clientInfo
1253      */
1254     TextFieldPattern client;
1255     ClientOverlayInfo clientInfo;
1256     clientInfo.isShowMouseMenu = true;
1257 
1258     /**
1259      * @tc.steps: step2.call UpdateShowingSelectOverlay
1260      * @tc.expected: isUpdateMenu is true
1261      */
1262     client.UpdateShowingSelectOverlay(clientInfo);
1263     EXPECT_TRUE(clientInfo.isUpdateMenu);
1264 }
1265 
1266 /**
1267  * @tc.name: GetSelectOverlayInfo01
1268  * @tc.desc: test GetSelectOverlayInfo
1269  * @tc.type: FUNC
1270  */
1271 HWTEST_F(SelectOverlayManagerTestNg, GetSelectOverlayInfo01, TestSize.Level1)
1272 {
1273     /**
1274      * @tc.steps: step1. Init client and clientInfo
1275      */
1276     TextFieldPattern client;
1277     ClientOverlayInfo clientInfo;
1278     clientInfo.isUpdateMenu = false;
1279 
1280     /**
1281      * @tc.steps: step2.call GetSelectOverlayInfo
1282      * @tc.expected: handlerColor equals the default handlerColor
1283      */
1284     client.selectOverlayInfo_.handlerColor = Color::BLUE;
1285     auto selectOverlayInfo = client.GetSelectOverlayInfo(clientInfo);
1286     ASSERT_TRUE(selectOverlayInfo->handlerColor.has_value());
1287     EXPECT_TRUE(selectOverlayInfo->handlerColor.value() == client.selectOverlayInfo_.handlerColor.value());
1288 
1289     /**
1290      * @tc.steps: step3.set handlerColor and call GetSelectOverlayInfo
1291      * @tc.expected: handlerColor equals the setting handlerColor
1292      */
1293     clientInfo.handlerColor = Color::RED;
1294     selectOverlayInfo = client.GetSelectOverlayInfo(clientInfo);
1295     ASSERT_TRUE(selectOverlayInfo->handlerColor.has_value());
1296     EXPECT_TRUE(selectOverlayInfo->handlerColor.value() == Color::RED);
1297 }
1298 
1299 /**
1300  * @tc.name: InitSelectOverlay
1301  * @tc.desc: test InitSelectOverlay
1302  * @tc.type: FUNC
1303  */
1304 HWTEST_F(SelectOverlayManagerTestNg, InitSelectOverlay, TestSize.Level1)
1305 {
1306     /**
1307      * @tc.steps: step1. InitSelectOverlay
1308      */
1309     TextFieldPattern client;
1310     client.InitSelectOverlay();
1311     client.selectOverlayInfo_.menuCallback.onCopy();
1312     EXPECT_FALSE(client.SelectOverlayIsOn());
1313 
1314     client.InitSelectOverlay();
1315     client.selectOverlayInfo_.menuCallback.onCut();
1316     EXPECT_FALSE(client.SelectOverlayIsOn());
1317 
1318     client.InitSelectOverlay();
1319     client.selectOverlayInfo_.menuCallback.onSelectAll();
1320     EXPECT_FALSE(client.SelectOverlayIsOn());
1321 
1322     client.InitSelectOverlay();
1323     client.selectOverlayInfo_.menuCallback.onPaste();
1324     EXPECT_FALSE(client.SelectOverlayIsOn());
1325 
1326     client.InitSelectOverlay();
1327     client.selectOverlayInfo_.menuCallback.onCameraInput();
1328     EXPECT_FALSE(client.SelectOverlayIsOn());
1329 
1330     client.InitSelectOverlay();
1331     client.selectOverlayInfo_.menuCallback.onAIWrite();
1332     EXPECT_FALSE(client.SelectOverlayIsOn());
1333 
1334     bool isFirst = true;
1335     GestureEvent info;
1336     client.InitSelectOverlay();
1337     client.selectOverlayInfo_.onHandleMoveStart(info, isFirst);
1338     EXPECT_TRUE(isFirst);
1339 
1340     RectF area;
1341     area = RectF(1, 1, 1, 1);
1342     client.InitSelectOverlay();
1343     client.selectOverlayInfo_.onHandleMove(area, isFirst);
1344     EXPECT_TRUE(isFirst);
1345 
1346     area = RectF(1, 2, 2, 2);
1347     client.InitSelectOverlay();
1348     client.selectOverlayInfo_.onHandleMoveDone(area, isFirst);
1349     EXPECT_TRUE(isFirst);
1350 
1351     bool closedByGlobalEvent = true;
1352     client.InitSelectOverlay();
1353     client.selectOverlayInfo_.onClose(closedByGlobalEvent);
1354     EXPECT_TRUE(isFirst);
1355 }
1356 
1357 /**
1358  * @tc.name: RequestOpenSelectOverlay001
1359  * @tc.desc: test RequestOpenSelectOverlay001
1360  * @tc.type: FUNC
1361  */
1362 HWTEST_F(SelectOverlayManagerTestNg, RequestOpenSelectOverlay001, TestSize.Level1)
1363 {
1364     /**
1365      * @tc.steps: step1. RequestOpenSelectOverlay001
1366      */
1367     TextFieldPattern client;
1368     ClientOverlayInfo clientInfo;
1369 
1370     EXPECT_FALSE(client.SelectOverlayIsOn());
1371     client.RequestOpenSelectOverlay(clientInfo);
1372 }
1373 
1374 /**
1375  * @tc.name: RequestOpenSelectOverlay002
1376  * @tc.desc: test RequestOpenSelectOverlay002
1377  * @tc.type: FUNC
1378  */
1379 HWTEST_F(SelectOverlayManagerTestNg, RequestOpenSelectOverlay002, TestSize.Level1)
1380 {
1381     /**
1382      * @tc.steps: step1. RequestOpenSelectOverlay002
1383      */
1384     TextFieldPattern client;
1385     ClientOverlayInfo clientInfo;
1386 
1387     client.RequestOpenSelectOverlay(clientInfo);
1388     EXPECT_FALSE(client.SelectOverlayIsOn());
1389 }
1390 
1391 /**
1392  * @tc.name: CreateSelectOverlay01
1393  * @tc.desc: test CreateSelectOverlay01
1394  * @tc.type: FUNC
1395  */
1396 HWTEST_F(SelectOverlayManagerTestNg, CreateSelectOverlay01, TestSize.Level1)
1397 {
1398     /**
1399      * @tc.steps: step1. CreateSelectOverlay01
1400      */
1401     TextFieldPattern client;
1402     ClientOverlayInfo clientInfo;
1403     SelectOverlayInfo selectOverlayInfo;
1404 
1405     selectOverlayInfo.isUsingMouse = IS_USING_MOUSE;
1406     client.CreateSelectOverlay(clientInfo);
1407     EXPECT_TRUE(selectOverlayInfo.isUsingMouse);
1408 
1409 
1410     selectOverlayInfo.isUsingMouse = false;
1411     client.CreateSelectOverlay(clientInfo);
1412     EXPECT_FALSE(selectOverlayInfo.isUsingMouse);
1413 }
1414 
1415 /**
1416  * @tc.name: CreateSelectOverlay02
1417  * @tc.desc: test CreateSelectOverlay02
1418  * @tc.type: FUNC
1419  */
1420 HWTEST_F(SelectOverlayManagerTestNg, CreateSelectOverlay02, TestSize.Level1)
1421 {
1422     /**
1423      * @tc.steps: step1. CreateSelectOverlay02
1424      */
1425     TextFieldPattern client;
1426     ClientOverlayInfo clientInfo;
1427     SelectOverlayInfo selectOverlayInfo;
1428 
1429     selectOverlayInfo.isUsingMouse = false;
1430     client.CreateSelectOverlay(clientInfo);
1431     EXPECT_FALSE(selectOverlayInfo.isUsingMouse);
1432 }
1433 
1434 /**
1435  * @tc.name: UpdateShowingSelectOverlay03
1436  * @tc.desc: test UpdateShowingSelectOverlay03
1437  * @tc.type: FUNC
1438  */
1439 HWTEST_F(SelectOverlayManagerTestNg, UpdateShowingSelectOverlay03, TestSize.Level1)
1440 {
1441     /**
1442      * @tc.steps: step1. UpdateShowingSelectOverlay03
1443      */
1444     TextFieldPattern client;
1445     ClientOverlayInfo clientInfo;
1446     SelectHandleInfo handleInfo;
1447     SelectHandleInfo secondInfo;
1448     secondInfo.isShow = false;
1449     clientInfo.isShowMouseMenu = false;
1450     clientInfo.secondHandleInfo = secondInfo;
1451 
1452     clientInfo.isNewAvoid = true;
1453     client.UpdateShowingSelectOverlay(clientInfo);
1454     EXPECT_TRUE(clientInfo.isNewAvoid);
1455 
1456     clientInfo.isUpdateMenu = true;
1457     client.UpdateShowingSelectOverlay(clientInfo);
1458 
1459     clientInfo.firstHandleInfo = handleInfo;
1460     client.UpdateShowingSelectOverlay(clientInfo);
1461 }
1462 
1463 /**
1464  * @tc.name: UpdateSelectInfo
1465  * @tc.desc: test UpdateSelectInfo
1466  * @tc.type: FUNC
1467  */
1468 HWTEST_F(SelectOverlayManagerTestNg, UpdateSelectInfo, TestSize.Level1)
1469 {
1470     /**
1471      * @tc.steps: step1. UpdateSelectInfo
1472      */
1473     TextFieldPattern client;
1474     SelectOverlayInfo selectOverlayInfo;
1475     const std::string selectInfo = "selectInfo";
1476     client.UpdateSelectInfo(selectInfo);
1477     selectOverlayInfo.selectText = selectInfo;
1478     EXPECT_EQ(selectOverlayInfo.selectText, selectInfo);
1479 }
1480 
1481 /**
1482  * @tc.name: UpdateSelectMenuInfo
1483  * @tc.desc: test UpdateSelectMenuInfo
1484  * @tc.type: FUNC
1485  */
1486 HWTEST_F(SelectOverlayManagerTestNg, UpdateSelectMenuInfo, TestSize.Level1)
1487 {
1488     /**
1489      * @tc.steps: step1. UpdateSelectMenuInfo
1490      */
1491     TextFieldPattern client;
1492     SelectOverlayInfo selectOverlayInfo;
1493     std::function<void(SelectMenuInfo&)> updateAction;
1494     client.UpdateSelectMenuInfo(updateAction);
1495     EXPECT_FALSE(selectOverlayInfo.isUseOverlayNG);
1496 }
1497 
1498 /**
1499  * @tc.name: UpdateSelectMenuVisibility001
1500  * @tc.desc: test UpdateSelectMenuVisibility001
1501  * @tc.type: FUNC
1502  */
1503 HWTEST_F(SelectOverlayManagerTestNg, UpdateSelectMenuVisibility001, TestSize.Level1)
1504 {
1505     /**
1506      * @tc.steps: step1. UpdateSelectMenuVisibility001
1507      */
1508     TextFieldPattern client;
1509     SelectOverlayInfo selectOverlayInfo;
1510     bool isVisible = true;
1511     client.UpdateSelectMenuVisibility(isVisible);
1512     EXPECT_TRUE(isVisible);
1513 }
1514 
1515 /**
1516  * @tc.name: UpdateSelectMenuVisibility002
1517  * @tc.desc: test UpdateSelectMenuVisibility002
1518  * @tc.type: FUNC
1519  */
1520 HWTEST_F(SelectOverlayManagerTestNg, UpdateSelectMenuVisibility002, TestSize.Level1)
1521 {
1522     /**
1523      * @tc.steps: step1. UpdateSelectMenuVisibility002
1524      */
1525     TextFieldPattern client;
1526     SelectOverlayInfo selectOverlayInfo;
1527     bool isVisible = false;
1528     client.UpdateSelectMenuVisibility(isVisible);
1529     EXPECT_FALSE(isVisible);
1530 }
1531 
1532 /**
1533  * @tc.name: StartListeningScrollableParent001
1534  * @tc.desc: test StartListeningScrollableParent001
1535  * @tc.type: FUNC
1536  */
1537 HWTEST_F(SelectOverlayManagerTestNg, StartListeningScrollableParent001, TestSize.Level1)
1538 {
1539     /**
1540      * @tc.steps: step1. StartListeningScrollableParent001
1541      */
1542     TextFieldPattern client;
1543     ScrollableParentInfo scrollableParentInfo;
1544     scrollableParentInfo.hasParent = true;
1545     client.StartListeningScrollableParent(root_);
1546     EXPECT_TRUE(scrollableParentInfo.hasParent);
1547 }
1548 
1549 /**
1550  * @tc.name: StopListeningScrollableParent
1551  * @tc.desc: test StopListeningScrollableParent
1552  * @tc.type: FUNC
1553  */
1554 HWTEST_F(SelectOverlayManagerTestNg, StopListeningScrollableParent, TestSize.Level1)
1555 {
1556     /**
1557      * @tc.steps: step1. StopListeningScrollableParent
1558      */
1559     TextFieldPattern client;
1560     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
1561     client.StopListeningScrollableParent(root);
1562     EXPECT_NE(root, nullptr);
1563 }
1564 
1565 /**
1566  * @tc.name: GetVisibleContentRect
1567  * @tc.desc: test GetVisibleContentRect
1568  * @tc.type: FUNC
1569  */
1570 HWTEST_F(SelectOverlayManagerTestNg, GetVisibleContentRect, TestSize.Level1)
1571 {
1572     /**
1573      * @tc.steps: step1. GetVisibleContentRect
1574      */
1575     TextFieldPattern client;
1576     RectF visibleRect;
1577     visibleRect = RectF(1, 1, 1, 1);
1578     client.GetVisibleContentRect(root_, visibleRect);
1579     EXPECT_NE(visibleRect.GetY(), 0);
1580 }
1581 
1582 /**
1583  * @tc.name: SetHolder
1584  * @tc.desc: test SetHolder
1585  * @tc.type: FUNC
1586  */
1587 HWTEST_F(SelectOverlayManagerTestNg, SetHolder, TestSize.Level1)
1588 {
1589     /**
1590      * @tc.steps: step1. SetHolder
1591      */
1592     auto content = SelectContentOverlayManager(root_);
1593     content.SetHolder(nullptr);
1594 
1595     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1596     content.SetHolder(holder);
1597 
1598     content.selectionHoldId_ = 1;
1599     content.SetHolder(holder);
1600 }
1601 
1602 /**
1603  * @tc.name: SetHolderInternal
1604  * @tc.desc: test SetHolderInternal
1605  * @tc.type: FUNC
1606  */
1607 HWTEST_F(SelectOverlayManagerTestNg, SetHolderInternal, TestSize.Level1)
1608 {
1609     /**
1610      * @tc.steps: step1. SetHolderInternal
1611      */
1612     auto content = SelectContentOverlayManager(root_);
1613     content.SetHolderInternal(nullptr);
1614 
1615     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1616     content.SetHolder(holder);
1617 
1618     content.SetHolder(holder);
1619     content.SetHolderInternal(holder);
1620     EXPECT_EQ(content.selectionHoldId_, -1);
1621 }
1622 
1623 /**
1624  * @tc.name: HasHolder
1625  * @tc.desc: test HasHolder
1626  * @tc.type: FUNC
1627  */
1628 HWTEST_F(SelectOverlayManagerTestNg, HasHolder, TestSize.Level1)
1629 {
1630     /**
1631      * @tc.steps: step1. HasHolder
1632      */
1633     auto content = SelectContentOverlayManager(root_);
1634     int32_t id = -1;
1635     bool hasHolder = content.HasHolder(id);
1636     EXPECT_FALSE(hasHolder);
1637 }
1638 
1639 /**
1640  * @tc.name: SelectContent Show
1641  * @tc.desc: test SelectContent Show
1642  * @tc.type: FUNC
1643  */
1644 HWTEST_F(SelectOverlayManagerTestNg, Show, TestSize.Level1)
1645 {
1646     /**
1647      * @tc.steps: step1. Show
1648      */
1649     auto content = SelectContentOverlayManager(root_);
1650     bool animation = true;
1651     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1652     content.SetHolder(holder);
1653     int32_t requestCode = -1;
1654     content.Show(animation, requestCode);
1655     EXPECT_EQ(content.selectionHoldId_, -1);
1656 }
1657 
1658 /**
1659  * @tc.name: SelectContent BuildSelectOverlayInfo
1660  * @tc.desc: test SelectContent BuildSelectOverlayInfo
1661  * @tc.type: FUNC
1662  */
1663 HWTEST_F(SelectOverlayManagerTestNg, BuildSelectOverlayInfo, TestSize.Level1)
1664 {
1665     /**
1666      * @tc.steps: step1. BuildSelectOverlayInfo
1667      */
1668     auto content = SelectContentOverlayManager(root_);
1669     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1670     content.SetHolder(holder);
1671     int32_t requestCode = -1;
1672     content.BuildSelectOverlayInfo(requestCode);
1673     EXPECT_EQ(content.selectionHoldId_, -1);
1674 }
1675 
1676 /**
1677  * @tc.name: SelectContent UpdateStatusInfos
1678  * @tc.desc: test SelectContent UpdateStatusInfos
1679  * @tc.type: FUNC
1680  */
1681 HWTEST_F(SelectOverlayManagerTestNg, UpdateStatusInfos, TestSize.Level1)
1682 {
1683     /**
1684      * @tc.steps: step1. UpdateStatusInfos
1685      */
1686     auto content = SelectContentOverlayManager(root_);
1687     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1688     content.SetHolder(holder);
1689     SelectOverlayInfo info;
1690     content.UpdateStatusInfos(info);
1691     EXPECT_NE(holder, nullptr);
1692 }
1693 
1694 /**
1695  * @tc.name: MarkInfoChange
1696  * @tc.desc: test MarkInfoChange
1697  * @tc.type: FUNC
1698  */
1699 HWTEST_F(SelectOverlayManagerTestNg, MarkInfoChange, TestSize.Level1)
1700 {
1701     /**
1702      * @tc.steps: step1. MarkInfoChange
1703      */
1704     auto content = SelectContentOverlayManager(root_);
1705     SelectOverlayDirtyFlag dirty = 1;
1706 
1707     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1708     content.SetHolder(holder);
1709     content.MarkInfoChange(dirty);
1710     EXPECT_EQ(content.selectionHoldId_, -1);
1711 }
1712 
1713 /**
1714  * @tc.name: UpdateHandleInfosWithFlag
1715  * @tc.desc: test UpdateHandleInfosWithFlag
1716  * @tc.type: FUNC
1717  */
1718 HWTEST_F(SelectOverlayManagerTestNg, UpdateHandleInfosWithFlag, TestSize.Level1)
1719 {
1720     /**
1721      * @tc.steps: step1. UpdateHandleInfosWithFlag
1722      */
1723     auto content = SelectContentOverlayManager(root_);
1724     int32_t updateFlag = 1;
1725 
1726     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1727     content.SetHolder(holder);
1728     content.UpdateHandleInfosWithFlag(updateFlag);
1729 
1730     updateFlag = 2;
1731     content.UpdateHandleInfosWithFlag(updateFlag);
1732 
1733     updateFlag = 3;
1734     content.UpdateHandleInfosWithFlag(updateFlag);
1735     EXPECT_EQ(content.selectionHoldId_, -1);
1736 }
1737 
1738 /**
1739  * @tc.name: CreateSelectOverlay
1740  * @tc.desc: test CreateSelectOverlay
1741  * @tc.type: FUNC
1742  */
1743 HWTEST_F(SelectOverlayManagerTestNg, CreateSelectOverlay, TestSize.Level1)
1744 {
1745     /**
1746      * @tc.steps: step1. CreateSelectOverlay
1747      */
1748     auto content = SelectContentOverlayManager(root_);
1749     SelectOverlayInfo info;
1750     bool animation = true;
1751     content.CreateSelectOverlay(info, animation);
1752     EXPECT_EQ(content.selectionHoldId_, -1);
1753 }
1754 
1755 /**
1756  * @tc.name: MountNodeToRoot
1757  * @tc.desc: test MountNodeToRoot
1758  * @tc.type: FUNC
1759  */
1760 HWTEST_F(SelectOverlayManagerTestNg, MountNodeToRoot, TestSize.Level1)
1761 {
1762     /**
1763      * @tc.steps: step1. MountNodeToRoot
1764      */
1765     auto content = SelectContentOverlayManager(root_);
1766     bool animation = true;
1767     content.MountNodeToRoot(root_, animation);
1768     EXPECT_EQ(content.selectionHoldId_, -1);
1769 }
1770 
1771 /**
1772  * @tc.name: GetSelectOverlayRoot
1773  * @tc.desc: test GetSelectOverlayRoot
1774  * @tc.type: FUNC
1775  */
1776 HWTEST_F(SelectOverlayManagerTestNg, GetSelectOverlayRoot, TestSize.Level1)
1777 {
1778     /**
1779      * @tc.steps: step1. GetSelectOverlayRoot
1780      */
1781     auto content = SelectContentOverlayManager(root_);
1782     auto rootNode = content.GetSelectOverlayRoot();
1783     EXPECT_EQ(rootNode, nullptr);
1784 }
1785 
1786 /**
1787  * @tc.name: CloseInternal
1788  * @tc.desc: test CloseInternal
1789  * @tc.type: FUNC
1790  */
1791 HWTEST_F(SelectOverlayManagerTestNg, CloseInternal, TestSize.Level1)
1792 {
1793     /**
1794      * @tc.steps: step1. CloseInternal
1795      */
1796     auto content = SelectContentOverlayManager(root_);
1797     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1798     content.SetHolder(holder);
1799     int32_t id = 1;
1800     bool animation = true;
1801     CloseReason reason = CloseReason::CLOSE_REASON_NORMAL;
1802     content.CloseInternal(id, animation, reason);
1803     EXPECT_EQ(content.selectionHoldId_, -1);
1804 }
1805 
1806 /**
1807  * @tc.name: DestroySelectOverlayNode
1808  * @tc.desc: test DestroySelectOverlayNode
1809  * @tc.type: FUNC
1810  */
1811 HWTEST_F(SelectOverlayManagerTestNg, DestroySelectOverlayNode, TestSize.Level1)
1812 {
1813     /**
1814      * @tc.steps: step1. DestroySelectOverlayNode
1815      */
1816     auto content = SelectContentOverlayManager(root_);
1817     content.DestroySelectOverlayNode(root_);
1818     content.ClearAllStatus();
1819     EXPECT_EQ(content.selectionHoldId_, -1);
1820 }
1821 
1822 /**
1823  * @tc.name: ClearAllStatus
1824  * @tc.desc: test ClearAllStatus
1825  * @tc.type: FUNC
1826  */
1827 HWTEST_F(SelectOverlayManagerTestNg, ClearAllStatus, TestSize.Level1)
1828 {
1829     /**
1830      * @tc.steps: step1. ClearAllStatus
1831      */
1832     auto content = SelectContentOverlayManager(root_);
1833     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1834     content.SetHolder(holder);
1835     content.ClearAllStatus();
1836     EXPECT_NE(holder, nullptr);
1837 }
1838 
1839 /**
1840  * @tc.name: CloseCurrent
1841  * @tc.desc: test CloseCurrent
1842  * @tc.type: FUNC
1843  */
1844 HWTEST_F(SelectOverlayManagerTestNg, CloseCurrent, TestSize.Level1)
1845 {
1846     /**
1847      * @tc.steps: step1. CloseCurrent
1848      */
1849     auto content = SelectContentOverlayManager(root_);
1850     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1851     content.SetHolder(holder);
1852     bool animation = true;
1853     CloseReason reason = CloseReason::CLOSE_REASON_NORMAL;
1854     bool isCloseCurrent = content.CloseCurrent(animation, reason);
1855     EXPECT_FALSE(isCloseCurrent);
1856 }
1857 
1858 /**
1859  * @tc.name: ShowOptionMenu
1860  * @tc.desc: test ShowOptionMenu
1861  * @tc.type: FUNC
1862  */
1863 HWTEST_F(SelectOverlayManagerTestNg, ShowOptionMenu, TestSize.Level1)
1864 {
1865     /**
1866      * @tc.steps: step1. ShowOptionMenu
1867      */
1868     auto content = SelectContentOverlayManager(root_);
1869     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1870     content.SetHolder(holder);
1871     content.ShowOptionMenu();
1872     content.HideOptionMenu(true);
1873     content.ToggleOptionMenu();
1874     content.DisableMenu();
1875     content.EnableMenu();
1876     content.HideHandle();
1877     content.IsCreating();
1878     content.IsMenuShow();
1879     content.IsSingleHandle();
1880     bool isHandlesShow = content.IsHandlesShow();
1881     EXPECT_FALSE(isHandlesShow);
1882 }
1883 
1884 /**
1885  * @tc.name: IsHandleReverse
1886  * @tc.desc: test IsHandleReverse
1887  * @tc.type: FUNC
1888  */
1889 HWTEST_F(SelectOverlayManagerTestNg, IsHandleReverse, TestSize.Level1)
1890 {
1891     /**
1892      * @tc.steps: step1. IsHandleReverse
1893      */
1894     auto content = SelectContentOverlayManager(root_);
1895     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1896     content.SetHolder(holder);
1897     bool isHandle = content.IsHandleReverse();
1898     EXPECT_FALSE(isHandle);
1899 }
1900 
1901 /**
1902  * @tc.name: RestartHiddenHandleTask
1903  * @tc.desc: test RestartHiddenHandleTask
1904  * @tc.type: FUNC
1905  */
1906 HWTEST_F(SelectOverlayManagerTestNg, RestartHiddenHandleTask, TestSize.Level1)
1907 {
1908     /**
1909      * @tc.steps: step1. RestartHiddenHandleTask
1910      */
1911     auto content = SelectContentOverlayManager(root_);
1912     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1913     content.SetHolder(holder);
1914     bool isDelay = true;
1915     content.RestartHiddenHandleTask(isDelay);
1916     EXPECT_FALSE(content.isIntercept_);
1917 }
1918 
1919 /**
1920  * @tc.name: CancelHiddenHandleTask
1921  * @tc.desc: test RestartHiddenHandleTask
1922  * @tc.type: FUNC
1923  */
1924 HWTEST_F(SelectOverlayManagerTestNg, CancelHiddenHandleTask, TestSize.Level1)
1925 {
1926     /**
1927      * @tc.steps: step1. CancelHiddenHandleTask
1928      */
1929     auto content = SelectContentOverlayManager(root_);
1930     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1931     content.SetHolder(holder);
1932     content.CancelHiddenHandleTask();
1933     EXPECT_FALSE(content.isIntercept_);
1934 }
1935 
1936 /**
1937  * @tc.name: GetSelectOverlayNode
1938  * @tc.desc: test GetSelectOverlayNode
1939  * @tc.type: FUNC
1940  */
1941 HWTEST_F(SelectOverlayManagerTestNg, GetSelectOverlayNode, TestSize.Level1)
1942 {
1943     /**
1944      * @tc.steps: step1. GetSelectOverlayNode
1945      */
1946     auto content = SelectContentOverlayManager(root_);
1947     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1948     content.SetHolder(holder);
1949     auto selectOverlayNode = content.GetSelectOverlayNode();
1950     EXPECT_EQ(selectOverlayNode, nullptr);
1951 }
1952 
1953 /**
1954  * @tc.name: GetShowMenuType
1955  * @tc.desc: test GetShowMenuType
1956  * @tc.type: FUNC
1957  */
1958 HWTEST_F(SelectOverlayManagerTestNg, GetShowMenuType, TestSize.Level1)
1959 {
1960     /**
1961      * @tc.steps: step1. GetShowMenuType
1962      */
1963     auto content = SelectContentOverlayManager(root_);
1964     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1965     content.SetHolder(holder);
1966     content.GetShowMenuType();
1967     EXPECT_FALSE(content.IsOpen());
1968 }
1969 
1970 /**
1971  * @tc.name: ContentHandleGlobalEvent
1972  * @tc.desc: test SelectContentOverlayManager HandleGlobalEvent
1973  * @tc.type: FUNC
1974  */
1975 HWTEST_F(SelectOverlayManagerTestNg, ContentHandleGlobalEvent, TestSize.Level1)
1976 {
1977     /**
1978      * @tc.steps: step1. HandleGlobalEvent
1979      */
1980     Init();
1981     auto content = SelectContentOverlayManager(root_);
1982     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
1983     content.SetHolder(holder);
1984     TouchEvent touchPoint;
1985     content.HandleGlobalEvent(touchPoint, ROOT_OFFSET);
1986     EXPECT_NE(touchPoint.type, TouchType::DOWN);
1987     /**
1988      * @tc.steps: step2. Change the TouchEvent and call HandleGlobalEvent
1989      */
1990     touchPoint.type = TouchType::DOWN;
1991     content.HandleGlobalEvent(touchPoint, ROOT_OFFSET);
1992     EXPECT_NE(touchPoint.type, TouchType::UP);
1993 
1994     touchPoint.type = TouchType::UP;
1995     content.HandleGlobalEvent(touchPoint, ROOT_OFFSET);
1996     EXPECT_NE(touchPoint.type, TouchType::MOVE);
1997 }
1998 
1999 /**
2000  * @tc.name: IsTouchInSelectOverlayArea
2001  * @tc.desc: test IsTouchInSelectOverlayArea
2002  * @tc.type: FUNC
2003  */
2004 HWTEST_F(SelectOverlayManagerTestNg, IsTouchInSelectOverlayArea, TestSize.Level1)
2005 {
2006     /**
2007      * @tc.steps: step1. IsTouchInSelectOverlayArea
2008      */
2009     Init();
2010     auto content = SelectContentOverlayManager(root_);
2011     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
2012     PointF point { 9.0f, 12.0f };
2013     content.SetHolder(holder);
2014     content.IsTouchInSelectOverlayArea(point);
2015     EXPECT_FALSE(content.IsOpen());
2016 }
2017 
2018 /**
2019  * @tc.name: HandleSelectionEvent
2020  * @tc.desc: test HandleSelectionEvent
2021  * @tc.type: FUNC
2022  */
2023 HWTEST_F(SelectOverlayManagerTestNg, HandleSelectionEvent, TestSize.Level1)
2024 {
2025     /**
2026      * @tc.steps: step1. HandleSelectionEvent
2027      */
2028     Init();
2029     auto content = SelectContentOverlayManager(root_);
2030     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
2031     PointF point { 9.0f, 12.0f };
2032     content.SetHolder(holder);
2033     TouchEvent touchPoint;
2034     touchPoint.type = TouchType::UP;
2035     content.HandleSelectionEvent(point, touchPoint);
2036     EXPECT_FALSE(content.IsOpen());
2037 }
2038 
2039 /**
2040  * @tc.name: ResetSelectionRect
2041  * @tc.desc: test ResetSelectionRect
2042  * @tc.type: FUNC
2043  */
2044 HWTEST_F(SelectOverlayManagerTestNg, ResetSelectionRect, TestSize.Level1)
2045 {
2046     /**
2047      * @tc.steps: step1. ResetSelectionRect
2048      */
2049     Init();
2050     auto content = SelectContentOverlayManager(root_);
2051     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
2052     content.SetHolder(holder);
2053     HoldSelectionInfo holdSelectionInfo_;
2054     holdSelectionInfo_ = {};
2055     content.ResetSelectionRect();
2056     EXPECT_EQ(content.selectionHoldId_, -1);
2057 }
2058 
2059 /**
2060  * @tc.name: SetHoldSelectionCallback
2061  * @tc.desc: test SetHoldSelectionCallback
2062  * @tc.type: FUNC
2063  */
2064 HWTEST_F(SelectOverlayManagerTestNg, SetHoldSelectionCallback, TestSize.Level1)
2065 {
2066     /**
2067      * @tc.steps: step1. SetHoldSelectionCallback
2068      */
2069     Init();
2070     auto content = SelectContentOverlayManager(root_);
2071     int32_t id = -1;
2072     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
2073     HoldSelectionInfo holdSelectionInfo_;
2074     holdSelectionInfo_ = {};
2075     content.SetHolder(holder);
2076     content.SetHoldSelectionCallback(id, holdSelectionInfo_);
2077     EXPECT_EQ(content.selectionHoldId_, -1);
2078     id = 1;
2079     content.SetHoldSelectionCallback(id, holdSelectionInfo_);
2080     EXPECT_EQ(content.selectionHoldId_, 1);
2081 }
2082 
2083 /**
2084  * @tc.name: RemoveHoldSelectionCallback
2085  * @tc.desc: test RemoveHoldSelectionCallback
2086  * @tc.type: FUNC
2087  */
2088 HWTEST_F(SelectOverlayManagerTestNg, RemoveHoldSelectionCallback, TestSize.Level1)
2089 {
2090     /**
2091      * @tc.steps: step1. RemoveHoldSelectionCallback
2092      */
2093     Init();
2094     auto content = SelectContentOverlayManager(root_);
2095     HoldSelectionInfo holdSelectionInfo_;
2096     holdSelectionInfo_ = {};
2097     int32_t id = -1;
2098     auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
2099     content.SetHolder(holder);
2100     content.RemoveHoldSelectionCallback(id);
2101     id = 1;
2102     content.RemoveHoldSelectionCallback(id);
2103     EXPECT_EQ(content.selectionHoldId_, -1);
2104 }
2105 
2106 /**
2107  * @tc.name: SwitchToHandleMode
2108  * @tc.desc: test SwitchToHandleMode
2109  * @tc.type: FUNC
2110  */
2111 HWTEST_F(SelectOverlayManagerTestNg, SwitchToHandleMode, TestSize.Level1)
2112 {
2113     /**
2114      * @tc.steps: step1. Crate SelectContentOverlayManager and SelectOverlayHolder.
2115      */
2116     Init();
2117     auto content = AceType::MakeRefPtr<SelectContentOverlayManager>(root_);
2118     auto holder = AceType::MakeRefPtr<MockSelectOverlayHolder>();
2119     content->SetHolder(holder);
2120     content->Show(false, 0);
2121     EXPECT_NE(content->handleNode_.Upgrade(), nullptr);
2122     EXPECT_NE(content->menuNode_.Upgrade(), nullptr);
2123     /**
2124      * @tc.steps: step2. SwitchToHandleMode OVERLAY mode.
2125      */
2126     content->SwitchToHandleMode(HandleLevelMode::OVERLAY);
2127     EXPECT_EQ(holder->handleLevelMode_, HandleLevelMode::OVERLAY);
2128 
2129     /**
2130      * @tc.steps: step3. SwitchToHandleMode EMBED mode.
2131      */
2132     content->SwitchToHandleMode(HandleLevelMode::EMBED, false);
2133     EXPECT_EQ(holder->handleLevelMode_, HandleLevelMode::OVERLAY);
2134     holder->allowSwitchMode_ = true;
2135     holder->SetOwner(root_);
2136     content->SwitchToHandleMode(HandleLevelMode::EMBED, false);
2137     EXPECT_EQ(holder->handleLevelMode_, HandleLevelMode::EMBED);
2138 }
2139 
2140 /**
2141  * @tc.name: ClickAndSwitchToHandleMode
2142  * @tc.desc: test click to switch overlay mode.
2143  * @tc.type: FUNC
2144  */
2145 HWTEST_F(SelectOverlayManagerTestNg, ClickAndSwitchToHandleMode, TestSize.Level1)
2146 {
2147     /**
2148      * @tc.steps: step1. Crate SelectContentOverlayManager and SelectOverlayHolder.
2149      */
2150     Init();
2151     auto content = AceType::MakeRefPtr<SelectContentOverlayManager>(root_);
2152     auto holder = AceType::MakeRefPtr<MockSelectOverlayHolder>();
2153     content->SetHolder(holder);
2154     content->Show(false, 0);
2155     ASSERT_NE(content->handleNode_.Upgrade(), nullptr);
2156     ASSERT_NE(content->menuNode_.Upgrade(), nullptr);
2157     /**
2158      * @tc.steps: step2. SwitchToHandleMode EMBED mode.
2159      */
2160     content->SwitchToHandleMode(HandleLevelMode::EMBED);
2161     EXPECT_EQ(holder->handleLevelMode_, HandleLevelMode::EMBED);
2162 
2163     /**
2164      * @tc.steps: step3. click handle to switch overlay mode.
2165      */
2166     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(content->menuNode_.Upgrade());
2167     ASSERT_NE(selectOverlayNode, nullptr);
2168     auto selectOverlayPattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2169     ASSERT_NE(selectOverlayPattern, nullptr);
2170     selectOverlayPattern->isFirstHandleTouchDown_ = true;
2171     selectOverlayPattern->isSecondHandleTouchDown_ = true;
2172     TouchEventInfo info("");
2173     TouchLocationInfo location(1);
2174     location.SetLocalLocation(Offset(0.0f, 0.0f));
2175     location.touchType_ = TouchType::UP;
2176     info.changedTouches_ = { location };
2177     auto pipeline = PipelineContext::GetCurrentContext();
2178     ASSERT_NE(pipeline, nullptr);
2179     auto overlayManager = pipeline->GetSelectOverlayManager();
2180     ASSERT_NE(overlayManager, nullptr);
2181     overlayManager->selectContentManager_ = content;
2182     holder->allowSwitchMode_ = true;
2183     selectOverlayPattern->HandleTouchEvent(info);
2184     EXPECT_EQ(holder->handleLevelMode_, HandleLevelMode::OVERLAY);
2185 }
2186 } // namespace OHOS::Ace::NG
2187