1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <vector>
16 
17 #include "gtest/gtest.h"
18 #include "gtest/internal/gtest-internal.h"
19 
20 #define protected public
21 #define private public
22 
23 #include "test/mock/base/mock_task_executor.h"
24 #include "test/mock/core/common/mock_theme_manager.h"
25 #include "test/mock/core/pipeline/mock_pipeline_context.h"
26 #include "test/mock/core/rosen/mock_canvas.h"
27 
28 #include "base/geometry/dimension_rect.h"
29 #include "base/geometry/ng/offset_t.h"
30 #include "base/geometry/ng/rect_t.h"
31 #include "base/geometry/ng/size_t.h"
32 #include "base/memory/referenced.h"
33 #include "core/components/common/layout/constants.h"
34 #include "core/components/select/select_theme.h"
35 #include "core/components/text_overlay/text_overlay_theme.h"
36 #include "core/components/theme/theme.h"
37 #include "core/components_ng/base/frame_node.h"
38 #include "core/components_ng/base/modifier.h"
39 #include "core/components_ng/layout/layout_property.h"
40 #include "core/components_ng/pattern/button/button_pattern.h"
41 #include "core/components_ng/pattern/menu/menu_layout_property.h"
42 #include "core/components_ng/pattern/menu/menu_pattern.h"
43 #include "core/components_ng/pattern/menu/menu_theme.h"
44 #include "core/components_ng/pattern/select_overlay/select_overlay_node.h"
45 #include "core/components_ng/pattern/select_overlay/select_overlay_pattern.h"
46 #include "core/components_ng/pattern/select_overlay/select_overlay_property.h"
47 #include "core/pipeline/base/constants.h"
48 
49 using namespace testing;
50 using namespace testing::ext;
51 
52 namespace OHOS::Ace::NG {
53 namespace {
54 const std::string TEST_TAG = "Test";
55 constexpr int32_t NODE_ID = 143;
56 constexpr int32_t NODE_ID2 = 153;
57 constexpr int32_t NODE_ID3 = 10;
58 const RectF FIRST_HANDLE_REGION(0, 0, 10, 10);
59 const RectF SECOND_HANDLE_REGION(10, 10, 10, 10);
60 const RectF SECOND_HANDLE_REGION2(20, 20, 10, 10);
61 const float FIRST_ITEM_WIDTH = 150.0f;
62 const float FIRST_ITEM_HEIGHT = 75.0f;
63 const SizeF FIRST_ITEM_SIZE(FIRST_ITEM_WIDTH, FIRST_ITEM_HEIGHT);
64 const Color COLOR_ALPHA_MASK = Color::FromRGB(255, 100, 100);
65 constexpr MenuType TYPE = MenuType::MENU;
66 const OffsetF offset(10, 10);
67 int32_t callBackFlag = 0;
68 constexpr float RK356_HEIGHT = 1136.0f;
69 const OffsetF OFFSET_ITEM1 = OffsetF(5, 5);
70 } // namespace
71 
72 class SelectOverlayTestNg : public testing::Test {
73 public:
74     static void SetUpTestCase();
75     static void TearDownTestCase();
76 
77 protected:
78     std::vector<MenuOptionsParam> GetMenuOptionItems();
79     DrawingContext GetDrawingContext(Testing::MockCanvas& canvas);
80 };
81 
SetUpTestCase()82 void SelectOverlayTestNg::SetUpTestCase()
83 {
84     MockPipelineContext::SetUp();
85     // set SelectTheme to themeManager before using themeManager to get SelectTheme
86     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
87     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
88     auto selectTheme = AceType::MakeRefPtr<SelectTheme>();
89     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(selectTheme));
90 }
91 
TearDownTestCase()92 void SelectOverlayTestNg::TearDownTestCase()
93 {
94     MockPipelineContext::TearDown();
95 }
96 
GetMenuOptionItems()97 std::vector<MenuOptionsParam> SelectOverlayTestNg::GetMenuOptionItems()
98 {
99     std::vector<MenuOptionsParam> menuOptionItems;
100     MenuOptionsParam menuOptionItem1;
101     menuOptionItem1.content = "test1";
102     menuOptionItem1.action = [](const std::string&) {};
103     MenuOptionsParam menuOptionItem2;
104     menuOptionItem2.content = "test2";
105     menuOptionItem2.action = [](const std::string&) {};
106     menuOptionItems.emplace_back(menuOptionItem1);
107     menuOptionItems.emplace_back(menuOptionItem2);
108     return menuOptionItems;
109 }
110 
GetDrawingContext(Testing::MockCanvas & canvas)111 DrawingContext SelectOverlayTestNg::GetDrawingContext(Testing::MockCanvas& canvas)
112 {
113     DrawingContext context { canvas, 100, 100 };
114     EXPECT_CALL(canvas, Save()).Times(AnyNumber());
115     EXPECT_CALL(canvas, DrawLine(_, _)).Times(AnyNumber());
116     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
117     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
118     EXPECT_CALL(canvas, Rotate(_, _, _)).Times(AnyNumber());
119     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
120     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
121     EXPECT_CALL(canvas, DrawCircle(_, _)).Times(AnyNumber());
122     EXPECT_CALL(canvas, Translate(_, _)).Times(AnyNumber());
123     EXPECT_CALL(canvas, Restore()).Times(AnyNumber());
124     EXPECT_CALL(canvas, ClipRect(_, _, _)).WillRepeatedly(Return());
125     return context;
126 }
127 
128 /**
129  * @tc.name: SelectFrameNodeCreator002
130  * @tc.desc: Test CreateSelectOverlayNode
131  * @tc.type: FUNC
132  */
133 HWTEST_F(SelectOverlayTestNg, SelectFrameNodeCreator002, TestSize.Level1)
134 {
135     /**
136      * @tc.steps: step1. Create selectOverlayNode with camera input.
137      * @tc.expected: the selectOverlayNode including selectMenu with camera input is created successfully.
138      */
139     SelectOverlayInfo selectInfo;
140     selectInfo.menuInfo.menuIsShow = true;
141     selectInfo.menuInfo.showCameraInput = true;
142     selectInfo.menuOptionItems = GetMenuOptionItems();
143     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
144     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
145     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
146     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
147     EXPECT_NE(selectOverlayNode->selectMenuInner_, nullptr);
148 }
149 
150 /**
151  * @tc.name: SelectFrameNodeAnimationTest001
152  * @tc.desc: Test MoreAnimation and BackAnimation.
153  * @tc.type: FUNC
154  */
155 HWTEST_F(SelectOverlayTestNg, SelectFrameNodeAnimationTest001, TestSize.Level1)
156 {
157     /**
158      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
159      */
160     SelectOverlayInfo selectInfo;
161     selectInfo.menuInfo.menuDisable = true;
162     selectInfo.menuInfo.showCut = false;
163     selectInfo.menuInfo.showPaste = false;
164     auto menuOptionItems = GetMenuOptionItems();
165     selectInfo.menuOptionItems = menuOptionItems;
166     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
167     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
168     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
169     EXPECT_NE(selectOverlayNode, nullptr);
170     /**
171      * @tc.steps: step2. Create default menu and extension menu .
172      * @tc.expected: The default menu and extended menu are created successfully.
173      */
174     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
175     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
176     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
177     selectOverlayNode->CreateToolBar();
178     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
179     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0370402() 180         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
181     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
182     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<MenuTheme>()));
183     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
184     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
185     EXPECT_NE(selectOverlayNode->extensionMenu_, nullptr);
186     /**
187      * @tc.steps: step3. Execute MoreAnimation.
188      * @tc.expected: The node state switches correctly.
189      */
190     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
191     EXPECT_NE(pattern, nullptr);
192     pattern->CreateNodePaintMethod();
193     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
194     selectOverlayNode->MoreOrBackAnimation(true);
195     EXPECT_FALSE(selectOverlayNode->isExtensionMenu_);
196     /**
197      * @tc.steps: step4. Execute BackAnimation.
198      * @tc.expected: The node state switches correctly.
199      */
200     selectOverlayNode->isDoingAnimation_ = false;
201     selectOverlayNode->MoreOrBackAnimation(false);
202     EXPECT_FALSE(selectOverlayNode->isExtensionMenu_);
203 }
204 /**
205  * @tc.name: OnAttachToFrameNode001
206  * @tc.desc: Test SelectOverlayPattern OnAttachToFrameNode.
207  * @tc.type: FUNC
208  */
209 HWTEST_F(SelectOverlayTestNg, OnAttachToFrameNode001, TestSize.Level1)
210 {
211     /**
212      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
213      */
214     SelectOverlayInfo selectInfo;
215     selectInfo.menuOptionItems = GetMenuOptionItems();
216     selectInfo.singleLineHeight = NODE_ID;
217     selectInfo.isSingleHandle = true;
218     bool isShow[2] = { false, true };
219     for (int turn = 0; turn < 2; turn++) {
220         selectInfo.firstHandle.isShow = isShow[turn];
221         auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
222         MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
223         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
224         auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
225         auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
226         auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
227         ASSERT_NE(selectOverlayNode, nullptr);
228         /**
229          * @tc.steps: step2. Create pattern.
230          */
231         auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
232         ASSERT_NE(pattern, nullptr);
233         /**
234          * @tc.steps: step3. call OnAttachToFrameNode function.
235          * @tc.expected: the function exits normally.
236          */
237         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
238         ASSERT_NE(pattern->info_, nullptr);
239         pattern->info_->isHandleLineShow = isShow[turn];
240         pattern->OnAttachToFrameNode();
241         EXPECT_NE(pattern->GetSelectOverlayInfo(), nullptr);
242     }
243 }
244 /**
245  * @tc.name: UpdateSelectHandleInfo001
246  * @tc.desc: Test SelectOverlayPattern UpdateSelectHandleInfo.
247  * @tc.type: FUNC
248  */
249 HWTEST_F(SelectOverlayTestNg, UpdateSelectHandleInfo001, TestSize.Level1)
250 {
251     /**
252      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
253      */
254     SelectOverlayInfo selectInfo;
255     selectInfo.menuOptionItems = GetMenuOptionItems();
256     selectInfo.singleLineHeight = NODE_ID;
257     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
258     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
259     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
260     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
261     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
262     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
263     ASSERT_NE(selectOverlayNode, nullptr);
264     /**
265      * @tc.steps: step2. Create pattern.
266      */
267     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
268     ASSERT_NE(pattern, nullptr);
269     /**
270      * @tc.steps: step3. call UpdateHandleInfo functions without changing HandleInfo.
271      * @tc.expected: The branch of function runs correctly
272      */
273     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
274     pattern->UpdateFirstSelectHandleInfo(selectInfo.firstHandle);
275     pattern->UpdateSecondSelectHandleInfo(selectInfo.secondHandle);
276     pattern->UpdateFirstAndSecondHandleInfo(selectInfo.firstHandle, selectInfo.secondHandle);
277     EXPECT_EQ(pattern->info_->firstHandle, selectInfo.firstHandle);
278     EXPECT_EQ(pattern->info_->secondHandle, selectInfo.secondHandle);
279 }
280 /**
281  * @tc.name: UpdateSelectHandleInfo002
282  * @tc.desc: Test SelectOverlayPattern UpdateSelectHandleInfo.
283  * @tc.type: FUNC
284  */
285 HWTEST_F(SelectOverlayTestNg, UpdateSelectHandleInfo002, TestSize.Level1)
286 {
287     /**
288      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
289      */
290     SelectOverlayInfo selectInfo;
291     selectInfo.menuOptionItems = GetMenuOptionItems();
292     selectInfo.singleLineHeight = NODE_ID;
293     bool handleReverse[2] = { false, true };
294     for (int turn = 0; turn < 2; turn++) {
295         selectInfo.handleReverse = handleReverse[turn];
296         auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
297         MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
298         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
299         auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
300         auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
301         auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
302         ASSERT_NE(selectOverlayNode, nullptr);
303         /**
304          * @tc.steps: step2. Create pattern.
305          */
306         auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
307         ASSERT_NE(pattern, nullptr);
308         /**
309          * @tc.steps: step3. call UpdateHandleInfo functions with changing HandleInfo.
310          * @tc.expected: The branch of function runs correctly
311          */
312         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
313         SelectOverlayInfo selectInfo2;
314         selectInfo2.singleLineHeight = NODE_ID2;
315         selectInfo2.firstHandle.isShow = false;
316         selectInfo2.secondHandle.isShow = false;
317         SelectOverlayInfo selectInfo3;
318         selectInfo3.singleLineHeight = NODE_ID3;
319         pattern->UpdateFirstSelectHandleInfo(selectInfo2.firstHandle);
320         pattern->UpdateSecondSelectHandleInfo(selectInfo2.secondHandle);
321         pattern->UpdateFirstAndSecondHandleInfo(selectInfo3.firstHandle, selectInfo3.secondHandle);
322     }
323 }
324 /**
325  * @tc.name: OnDirtyLayoutWrapperSwap001
326  * @tc.desc: Test SelectOverlayPattern OnDirtyLayoutWrapperSwap.
327  * @tc.type: FUNC
328  */
329 HWTEST_F(SelectOverlayTestNg, OnDirtyLayoutWrapperSwap001, TestSize.Level1)
330 {
331     /**
332      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
333      */
334     SelectOverlayInfo selectInfo;
335     selectInfo.menuOptionItems = GetMenuOptionItems();
336     selectInfo.singleLineHeight = NODE_ID;
337     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
338     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
339     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
340     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
341     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
342     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
343     ASSERT_NE(selectOverlayNode, nullptr);
344     /**
345      * @tc.steps: step2. Create pattern and geometryNode.
346      */
347     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
348     ASSERT_NE(pattern, nullptr);
349     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
350     /**
351      * @tc.steps: step2. Call OnDirtyLayoutWrapperSwap function.
352      * @tc.expected: return false
353      */
354     auto layoutWrapper =
355         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
356     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
357     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
358     layoutWrapper->SetLayoutAlgorithm(
359         AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
360 
361     DirtySwapConfig config;
362     config.skipMeasure = true;
363     EXPECT_FALSE(pattern->OnDirtyLayoutWrapperSwap(layoutWrapper, config));
364 
365     layoutWrapper->skipMeasureContent_ = false;
366     config.skipMeasure = false;
367     EXPECT_TRUE(pattern->OnDirtyLayoutWrapperSwap(layoutWrapper, config));
368 }
369 /**
370  * @tc.name: UpdateShowArea001
371  * @tc.desc: Test SelectOverlayPattern UpdateShowArea.
372  * @tc.type: FUNC
373  */
374 HWTEST_F(SelectOverlayTestNg, UpdateShowArea001, TestSize.Level1)
375 {
376     /**
377      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
378      */
379     SelectOverlayInfo selectInfo;
380     selectInfo.menuOptionItems = GetMenuOptionItems();
381     selectInfo.singleLineHeight = NODE_ID;
382     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
383     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
384     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
385     ASSERT_NE(selectOverlayNode, nullptr);
386     /**
387      * @tc.steps: step2. Create pattern
388      */
389     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
390     ASSERT_NE(pattern, nullptr);
391     /**
392      * @tc.steps: step3. Call UpdateShowArea
393      * @tc.expected: the function exits normally
394      */
395     RectF area;
396     pattern->UpdateShowArea(area);
397     EXPECT_NE(pattern->GetSelectOverlayInfo(), nullptr);
398 
399     area = RectF(1, 1, 1, 1);
400     pattern->UpdateShowArea(area);
401     EXPECT_NE(pattern->GetSelectOverlayInfo(), nullptr);
402 }
403 
404 /**
405  * @tc.name: HandleOperator001
406  * @tc.desc: Test SelectOverlayPattern HandleOperator.
407  * @tc.type: FUNC
408  */
409 HWTEST_F(SelectOverlayTestNg, HandleOperator001, TestSize.Level1)
410 {
411     /**
412      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
413      */
414     SelectOverlayInfo selectInfo;
415     selectInfo.singleLineHeight = NODE_ID;
416     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
417     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
418     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
419     ASSERT_NE(selectOverlayNode, nullptr);
420     /**
421      * @tc.steps: step2. Create pattern
422      */
423     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
424     ASSERT_NE(pattern, nullptr);
425     /**
426      * @tc.steps: step3. Construct GestureEvent and Call UpdateShowArea
427      * @tc.expected: the function exits normally
428      */
429     GestureEvent info;
430     info.localLocation_ = Offset(1, 1);
431     pattern->HandleOnClick(info);
432     EXPECT_FALSE(pattern->GetSelectOverlayInfo()->isSingleHandle);
433     pattern->HandlePanEnd(info);
434     EXPECT_FALSE(pattern->GetSelectOverlayInfo()->isSingleHandle);
435     infoPtr->menuInfo.menuIsShow = true;
436     pattern->firstHandleDrag_ = true;
437     callBackFlag = 0;
__anonede6c0370502(const RectF& tmp, bool isFirst) 438     infoPtr->onHandleMoveDone = [&](const RectF& tmp, bool isFirst) {
439         callBackFlag = 1;
440     };
441     pattern->HandlePanEnd(info);
442     EXPECT_EQ(callBackFlag, 1);
443     pattern->firstHandleDrag_ = false;
444     pattern->secondHandleDrag_ = true;
445 
446     callBackFlag = 0;
447     pattern->HandlePanEnd(info);
448     EXPECT_EQ(callBackFlag, 1);
449 
450     /**
451      * @tc.steps: step4. Menu is not show, call HandleOnClick
452      * @tc.expected: menuIsShow is true.
453      */
454     ASSERT_NE(pattern->info_, nullptr);
455     pattern->info_->isSingleHandle = true;
456     pattern->info_->isHandleLineShow = false;
457     pattern->info_->menuInfo.menuIsShow = false;
458     pattern->HandleOnClick(info);
459     EXPECT_TRUE(pattern->info_->menuInfo.menuIsShow);
460 }
461 
462 /**
463  * @tc.name: HandleOperator002
464  * @tc.desc: Test SelectOverlayPattern HandleOperator.
465  * @tc.type: FUNC
466  */
467 HWTEST_F(SelectOverlayTestNg, HandleOperator002, TestSize.Level1)
468 {
469     /**
470      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
471      */
472     SelectOverlayInfo selectInfo;
473     selectInfo.singleLineHeight = NODE_ID;
474     selectInfo.isSingleHandle = true;
475     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
476     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
477     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
478     ASSERT_NE(selectOverlayNode, nullptr);
479     /**
480      * @tc.steps: step2. Create pattern and initialize HandleRegion
481      */
482     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
483     ASSERT_NE(pattern, nullptr);
484     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
485     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
486     /**
487      * @tc.steps: step3. Construct GestureEvent and Call HandleOperator functions in firstHandleRegion.
488      * @tc.expected: the function runs rightly
489      */
490     GestureEvent info;
491     info.localLocation_ = Offset(1, 1);
492     pattern->HandleOnClick(info);
493     EXPECT_TRUE(pattern->GetSelectOverlayInfo()->menuInfo.menuIsShow);
494     pattern->isFirstHandleTouchDown_ = true;
495     pattern->HandlePanStart(info);
496     EXPECT_TRUE(pattern->firstHandleDrag_);
497     const auto& offset = OffsetF(info.GetDelta().GetX(), info.GetDelta().GetY());
498     auto firstHandlePaintRect = pattern->GetSelectOverlayInfo()->firstHandle.paintRect + offset;
499     pattern->HandlePanMove(info);
500     auto firstHandlePaintRect2 = pattern->GetSelectOverlayInfo()->secondHandle.paintRect;
501     EXPECT_EQ(firstHandlePaintRect.GetX(), firstHandlePaintRect2.GetX());
502     pattern->HandlePanEnd(info);
503     EXPECT_FALSE(pattern->firstHandleDrag_);
504     /**
505      * @tc.steps: step4. Construct GestureEvent and Call HandleOperator functions in secondHandleRegion.
506      * @tc.expected: the function runs rightly
507      */
508     GestureEvent info2;
509     info2.localLocation_ = Offset(11, 11);
510     ASSERT_NE(pattern->info_, nullptr);
511     pattern->info_->isHandleLineShow = false;
512     pattern->isSecondHandleTouchDown_ = true;
513     pattern->HandlePanStart(info2);
514     EXPECT_TRUE(pattern->secondHandleDrag_);
515     const auto& offset2 = OffsetF(info2.GetDelta().GetX(), info2.GetDelta().GetY());
516     auto secondHandlePaintRect = pattern->GetSelectOverlayInfo()->secondHandle.paintRect + offset2;
517     pattern->HandlePanMove(info2);
518     auto secondHandlePaintRect2 = pattern->GetSelectOverlayInfo()->secondHandle.paintRect;
519     EXPECT_EQ(secondHandlePaintRect.GetX(), secondHandlePaintRect2.GetX());
520     pattern->HandlePanEnd(info2);
521     EXPECT_FALSE(pattern->secondHandleDrag_);
522     /**
523      * @tc.steps: step5. Construct GestureEvent and Call HandleOperator functions which is not in handleRegion.
524      * @tc.expected: the function runs rightly
525      */
526     GestureEvent info3;
527     info3.localLocation_ = Offset(21, 21);
528     pattern->info_->isSingleHandle = false;
529     pattern->HandlePanStart(info3);
530     pattern->HandlePanMove(info3);
531     EXPECT_FALSE(pattern->firstHandleDrag_);
532     EXPECT_FALSE(pattern->secondHandleDrag_);
533 
534     // in first region
535     GestureEvent info4;
536     info4.localLocation_ = Offset(1, 1);
537     pattern->info_->isSingleHandle = false;
538     callBackFlag = 0;
__anonede6c0370602(const GestureEvent& event, bool isFirst) 539     pattern->info_->onHandleMoveStart = [&](const GestureEvent& event, bool isFirst) {
540         callBackFlag = 1;
541     };
542     pattern->isFirstHandleTouchDown_ = true;
543     pattern->HandlePanStart(info4);
544     EXPECT_EQ(callBackFlag, 1);
545 
546     // not in first region and in second region
547     info4.localLocation_ = Offset(11, 11);
548     callBackFlag = 0;
549     pattern->isSecondHandleTouchDown_ = true;
550     pattern->HandlePanStart(info4);
551     EXPECT_EQ(callBackFlag, 1);
552 
553     // not in neither region
554     info4.localLocation_ = Offset(21, 21);
555     callBackFlag = 0;
556     pattern->info_->menuInfo.menuIsShow = false;
557 
558     for (int i = 0; i < 4; ++i) {
559         pattern->info_->isSingleHandle = i & 1;
560         pattern->info_->isHandleLineShow = i >> 1 & 1;
561         callBackFlag = 0;
562         pattern->HandlePanStart(info4);
563         EXPECT_EQ(callBackFlag, 0);
564     }
565 }
566 
567 /**
568  * @tc.name: HandleOperator003
569  * @tc.desc: Test SelectOverlayPattern HandleOperator.
570  * @tc.type: FUNC
571  */
572 HWTEST_F(SelectOverlayTestNg, HandleOperator003, TestSize.Level1)
573 {
574     /**
575      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
576      */
577     SelectOverlayInfo selectInfo;
578     selectInfo.singleLineHeight = NODE_ID;
579     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
580     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
581     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
582     ASSERT_NE(selectOverlayNode, nullptr);
583     /**
584      * @tc.steps: step2. Create pattern
585      */
586     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
587     ASSERT_NE(pattern, nullptr);
588     /**
589      * @tc.steps: step3. Construct TouchEventInfo and Call HandleTouchEvent function.
590      * @tc.expected: check whether the function is executed.
591      */
592     TouchEventInfo touchInfo("touchDown");
__anonede6c0370702(const TouchEventInfo& info) 593     infoPtr->onTouchDown = [](const TouchEventInfo& info) {
594         callBackFlag = 1;
595         return ;
596     };
__anonede6c0370802(const TouchEventInfo& info) 597     infoPtr->onTouchUp = [](const TouchEventInfo& info) {
598         callBackFlag = 2;
599         return ;
600     };
601     TouchLocationInfo touchLocationInfo(1);
602     touchLocationInfo.SetTouchType(TouchType::DOWN);
603     touchInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
604     pattern->HandleTouchEvent(touchInfo);
605     EXPECT_EQ(callBackFlag, 1);
606 }
607 
608 /**
609  * @tc.name: HandleOperator003
610  * @tc.desc: Test SelectOverlayPattern HandleOperator.
611  * @tc.type: FUNC
612  */
613 HWTEST_F(SelectOverlayTestNg, HandleOperator004, TestSize.Level1)
614 {
615     /**
616      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
617      */
618     SelectOverlayInfo selectInfo;
619     selectInfo.singleLineHeight = NODE_ID;
620     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
621     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
622     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
623     ASSERT_NE(selectOverlayNode, nullptr);
624     /**
625      * @tc.steps: step2. Create pattern
626      */
627     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
628     ASSERT_NE(pattern, nullptr);
629     /**
630      * @tc.steps: step3. Construct TouchEventInfo and Call HandleTouchEvent function.
631      * @tc.expected: check whether the function is executed.
632      */
633     TouchEventInfo touchInfo("touchDown");
__anonede6c0370902(const TouchEventInfo& info) 634     infoPtr->onTouchDown = [](const TouchEventInfo& info) {
635         callBackFlag = 1;
636         return;
637     };
__anonede6c0370a02(const TouchEventInfo& info) 638     infoPtr->onTouchUp = [](const TouchEventInfo& info) {
639         callBackFlag = 2;
640         return;
641     };
642     TouchLocationInfo touchLocationInfo(1);
643     touchLocationInfo.SetTouchType(TouchType::UP);
644     touchInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
645     pattern->HandleTouchEvent(touchInfo);
646     EXPECT_EQ(callBackFlag, 2);
647 }
648 
649 /**
650  * @tc.name: HandleOperator003
651  * @tc.desc: Test SelectOverlayPattern HandleOperator.
652  * @tc.type: FUNC
653  */
654 HWTEST_F(SelectOverlayTestNg, HandleOperator005, TestSize.Level1)
655 {
656     /**
657      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
658      */
659     SelectOverlayInfo selectInfo;
660     selectInfo.singleLineHeight = NODE_ID;
661     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
662     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
663     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
664     ASSERT_NE(selectOverlayNode, nullptr);
665     /**
666      * @tc.steps: step2. Create pattern
667      */
668     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
669     ASSERT_NE(pattern, nullptr);
670     /**
671      * @tc.steps: step3. Construct TouchEventInfo and Call HandleTouchEvent function.
672      * @tc.expected: check whether the function is executed.
673      */
674     TouchEventInfo touchInfo("touchDown");
__anonede6c0370b02(const TouchEventInfo& info) 675     infoPtr->onTouchDown = [](const TouchEventInfo& info) {
676         callBackFlag = 1;
677         return;
678     };
__anonede6c0370c02(const TouchEventInfo& info) 679     infoPtr->onTouchMove = [](const TouchEventInfo& info) {
680         callBackFlag = 3;
681         return;
682     };
683     TouchLocationInfo touchLocationInfo(1);
684     touchLocationInfo.SetTouchType(TouchType::MOVE);
685     touchInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
686     pattern->HandleTouchEvent(touchInfo);
687     EXPECT_EQ(callBackFlag, 3);
688 }
689 
690 /**
691  * @tc.name: CheckHandleReverse001
692  * @tc.desc: Test SelectOverlayPattern CheckHandleReverse.
693  * @tc.type: FUNC
694  */
695 HWTEST_F(SelectOverlayTestNg, CheckHandleReverse001, TestSize.Level1)
696 {
697     /**
698      * @tc.steps: step1. Create selectOverlayNode and initialize selectHandleInfo properties.
699      */
700     SelectOverlayInfo selectInfo;
701     selectInfo.singleLineHeight = NODE_ID3;
702     SelectHandleInfo firstHandle;
703     firstHandle.paintRect = FIRST_HANDLE_REGION;
704     SelectHandleInfo secondHandle;
705     secondHandle.paintRect = SECOND_HANDLE_REGION2;
706     selectInfo.firstHandle = firstHandle;
707     selectInfo.secondHandle = secondHandle;
708     bool handleReverse[2] = { false, true };
709     for (int turn = 0; turn < 2; turn++) {
710         selectInfo.handleReverse = handleReverse[turn];
711         auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
712         auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
713         auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
714         ASSERT_NE(selectOverlayNode, nullptr);
715         /**
716          * @tc.steps: step2. Create pattern
717          */
718         auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
719         ASSERT_NE(pattern, nullptr);
720         /**
721          * @tc.steps: step3. call CheckHandleReverse function.
722          * @tc.expected: check whether the value of handleReverse is correct.
723          */
724         pattern->CheckHandleReverse();
725         auto res = pattern->GetSelectOverlayInfo()->handleReverse;
726         EXPECT_FALSE(res);
727     }
728 }
729 /**
730  * @tc.name: CheckHandleReverse002
731  * @tc.desc: Test SelectOverlayPattern CheckHandleReverse.
732  * @tc.type: FUNC
733  */
734 HWTEST_F(SelectOverlayTestNg, CheckHandleReverse002, TestSize.Level1)
735 {
736     /**
737      * @tc.steps: step1. Create selectOverlayNode and initialize selectHandleInfo properties.
738      */
739     SelectOverlayInfo selectInfo;
740     selectInfo.singleLineHeight = NODE_ID3;
741     SelectHandleInfo firstHandle;
742     firstHandle.paintRect = SECOND_HANDLE_REGION2;
743     SelectHandleInfo secondHandle;
744     secondHandle.paintRect = FIRST_HANDLE_REGION;
745     selectInfo.firstHandle = firstHandle;
746     selectInfo.secondHandle = secondHandle;
747     bool handleReverse[2] = { false, true };
748     for (int turn = 0; turn < 2; turn++) {
749         selectInfo.handleReverse = handleReverse[turn];
750         auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
751         auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
752         auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
753         ASSERT_NE(selectOverlayNode, nullptr);
754         /**
755          * @tc.steps: step2. Create pattern
756          */
757         auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
758         ASSERT_NE(pattern, nullptr);
759         /**
760          * @tc.steps: step3. call CheckHandleReverse function.
761          * @tc.expected: check whether the value of handleReverse is correct.
762          */
763         pattern->CheckHandleReverse();
764         auto res = pattern->GetSelectOverlayInfo()->handleReverse;
765         EXPECT_TRUE(res);
766     }
767 }
768 /**
769  * @tc.name: SelectOverlayLayout001
770  * @tc.desc: Test selectOverlay layout.
771  * @tc.type: FUNC
772  */
773 HWTEST_F(SelectOverlayTestNg, SelectOverlayLayout001, TestSize.Level1)
774 {
775     /**
776      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
777      */
778     SelectOverlayInfo selectInfo;
779     selectInfo.singleLineHeight = NODE_ID;
780     selectInfo.menuOptionItems = GetMenuOptionItems();
781     bool menuIsShow[2] = { false, true };
782     for (int turn = 0; turn < 2; turn++) {
783         selectInfo.menuInfo.menuIsShow = menuIsShow[turn];
784         auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
785         MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
786         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
787         auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
788         auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
789         auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
790         ASSERT_NE(selectOverlayNode, nullptr);
791         /**
792          * @tc.steps: step2. Create pattern and geometryNode.
793          */
794         auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
795         ASSERT_NE(pattern, nullptr);
796         RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
797         /**
798          * @tc.steps: step3. Get layoutWrapper and layoutAlgorithm.
799          * @tc.expected: layoutWrapper and layoutAlgorithm are created successfully
800          */
801         auto layoutWrapper =
802             AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
803         auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
804         ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
805         layoutWrapper->SetLayoutAlgorithm(
806             AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
807 
808         auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
809         childLayoutConstraint.selfIdealSize = OptionalSizeF(FIRST_ITEM_SIZE);
810         // create menu and extensionMenu
811         for (int i = 0; i < 3; i++) {
812             auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0370d02() 813                 V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "Test", TYPE); });
814             // add item to selectOverlayNode
815             selectOverlayNode->AddChild(item);
816             RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
817             firstGeometryNode->Reset();
818             RefPtr<LayoutWrapperNode> firstLayoutWrapper =
819                 AceType::MakeRefPtr<LayoutWrapperNode>(item, firstGeometryNode, item->GetLayoutProperty());
820             ASSERT_NE(firstLayoutWrapper, nullptr);
821             auto itemPattern = item->GetPattern<MenuPattern>();
822             ASSERT_NE(itemPattern, nullptr);
823             firstLayoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(childLayoutConstraint);
824             auto itemLayoutAlgorithm = itemPattern->CreateLayoutAlgorithm();
825             ASSERT_NE(itemLayoutAlgorithm, nullptr);
826             firstLayoutWrapper->SetLayoutAlgorithm(
827                 AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(itemLayoutAlgorithm));
828             firstLayoutWrapper->GetLayoutProperty()->UpdateUserDefinedIdealSize(
829                 CalcSize(CalcLength(FIRST_ITEM_WIDTH), CalcLength(FIRST_ITEM_HEIGHT)));
830             layoutWrapper->AppendChild(firstLayoutWrapper);
831         }
832 
833         /**
834          * @tc.steps: step4. use layoutAlgorithm to measure and layout.
835          * @tc.expected: the function runs rightly.
836          */
837         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
838         selectOverlayLayoutAlgorithm->Layout(AccessibilityManager::RawPtr(layoutWrapper));
839     }
840 }
841 /**
842  * @tc.name: SelectOverlayNodeTest001
843  * @tc.desc: Test IsInSelectedOrSelectOverlayArea with menuOptions.
844  * @tc.type: FUNC
845  */
846 HWTEST_F(SelectOverlayTestNg, SelectOverlayNodeTest001, TestSize.Level1)
847 {
848     /**
849      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
850      */
851     SelectOverlayInfo selectInfo;
852     selectInfo.singleLineHeight = NODE_ID;
853     selectInfo.menuOptionItems = GetMenuOptionItems();
854     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
855     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
856     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
857     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
858     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
859     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
860     ASSERT_NE(selectOverlayNode, nullptr);
861     /**
862      * @tc.steps: step2. Create pattern and initialize HandleRegion
863      */
864     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
865     ASSERT_NE(pattern, nullptr);
866     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
867     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
868     /**
869      * @tc.steps: step3. Construct Point and Call IsInSelectedOrSelectOverlayArea.
870      * @tc.expected: return false
871      */
872     const NG::PointF point { 9.0f, 12.0f };
873     auto result = selectOverlayNode->IsInSelectedOrSelectOverlayArea(point);
874     EXPECT_FALSE(result);
875     /**
876      * @tc.steps: step4. Construct Point and Call IsInSelectedOrSelectOverlayArea.
877      * @tc.expected: return true
878      */
879     const NG::PointF point2 { 12.0f, 12.0f };
880     auto result2 = selectOverlayNode->IsInSelectedOrSelectOverlayArea(point2);
881     EXPECT_TRUE(result2);
882 }
883 
884 /**
885  * @tc.name: SelectOverlayNodeTest002
886  * @tc.desc: Test IsInSelectedOrSelectOverlayArea without menuOptions.
887  * @tc.type: FUNC
888  */
889 HWTEST_F(SelectOverlayTestNg, SelectOverlayNodeTest002, TestSize.Level1)
890 {
891     /**
892      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
893      */
894     SelectOverlayInfo selectInfo;
895     selectInfo.singleLineHeight = NODE_ID;
896     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
897     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
898     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
899     ASSERT_NE(selectOverlayNode, nullptr);
900     /**
901      * @tc.steps: step2. Create pattern and initialize HandleRegion
902      */
903     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
904     ASSERT_NE(pattern, nullptr);
905     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
906     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
907     /**
908      * @tc.steps: step3. Construct Point and Call IsInSelectedOrSelectOverlayArea.
909      * @tc.expected: return false
910      */
911     const NG::PointF point { 9.0f, 12.0f };
912     auto result = selectOverlayNode->IsInSelectedOrSelectOverlayArea(point);
913     EXPECT_FALSE(result);
914     /**
915      * @tc.steps: step4. Construct Point and Call IsInSelectedOrSelectOverlayArea.
916      * @tc.expected: return true
917      */
918     const NG::PointF point2 { 12.0f, 12.0f };
919     auto result2 = selectOverlayNode->IsInSelectedOrSelectOverlayArea(point2);
920     EXPECT_TRUE(result2);
921 }
922 /**
923  * @tc.name: SelectFrameNodeAnimationTest002
924  * @tc.desc: Test MoreAnimation and BackAnimation when isShowInDefaultMenu is false.
925  * @tc.type: FUNC
926  */
927 HWTEST_F(SelectOverlayTestNg, SelectFrameNodeAnimationTest002, TestSize.Level1)
928 {
929     /**
930      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
931      */
932     SelectOverlayInfo selectInfo;
933     selectInfo.menuInfo.menuDisable = true;
934     selectInfo.menuInfo.showCut = false;
935     selectInfo.menuInfo.showPaste = false;
936     auto menuOptionItems = GetMenuOptionItems();
937     selectInfo.menuOptionItems = menuOptionItems;
938     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
939     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
940     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
941     EXPECT_NE(selectOverlayNode, nullptr);
942     /**
943      * @tc.steps: step2. Create default menu and extension menu .
944      * @tc.expected: The default menu and extended menu are created successfully.
945      */
946     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
947     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
948     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
949     selectOverlayNode->CreateToolBar();
950     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
951     for (int i = 0; i < 7; i++) {
952         selectOverlayNode->isShowInDefaultMenu_[i] = false;
953     }
954     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
955     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
956 }
957 
958 /**
959  * @tc.name: SetHasShowAnimation001
960  * @tc.desc: Test SetHasShowAnimation when argument is true.
961  * @tc.type: FUNC
962  */
963 HWTEST_F(SelectOverlayTestNg, SetHasShowAnimation001, TestSize.Level1)
964 {
965     /**
966      * @tc.steps: step1. Create selectOverlayNode and pattern.
967      */
968     SelectOverlayInfo selectInfo;
969     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
970     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
971     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
972     ASSERT_NE(selectOverlayNode, nullptr);
973     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
974     ASSERT_NE(pattern, nullptr);
975     /**
976      * @tc.steps: step2. call SetHasShowAnimation and argument is true .
977      * @tc.expected: The hasShowAnimation_ be changed success.
978      */
979     pattern->SetHasShowAnimation(true);
980     EXPECT_TRUE(pattern->hasShowAnimation_);
981 }
982 
983 /**
984  * @tc.name: SetFrameNodeStatus001
985  * @tc.desc: Test SetFrameNodeStatus different argument.
986  * @tc.type: FUNC
987  */
988 HWTEST_F(SelectOverlayTestNg, SetFrameNodeStatus001, TestSize.Level1)
989 {
990     /**
991      * @tc.steps: step1. Create and initialize selectOverlayNode and pattern.
992      */
993     SelectOverlayInfo selectInfo;
994     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
995     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
996     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
997     ASSERT_NE(selectOverlayNode, nullptr);
998     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
999     ASSERT_NE(pattern, nullptr);
1000     /**
1001      * @tc.steps: step2. call SetFrameNodeStatus and pass different parameters .
1002      * @tc.expected: the corresponding value was successfully changed.
1003      */
1004     selectOverlayNode->SetFrameNodeStatus(FrameNodeType::SELECTMENU, FrameNodeStatus::VISIBLE);
1005     EXPECT_EQ(selectOverlayNode->selectMenuStatus_, FrameNodeStatus::VISIBLE);
1006     selectOverlayNode->SetFrameNodeStatus(FrameNodeType::EXTENSIONMENU, FrameNodeStatus::VISIBLE);
1007     EXPECT_EQ(selectOverlayNode->extensionMenuStatus_, FrameNodeStatus::VISIBLE);
1008     selectOverlayNode->SetFrameNodeStatus(FrameNodeType::BACKBUTTON, FrameNodeStatus::VISIBLE);
1009     EXPECT_EQ(selectOverlayNode->backButtonStatus_, FrameNodeStatus::VISIBLE);
1010 }
1011 
1012 /**
1013  * @tc.name: SetFrameNodeVisibility001
1014  * @tc.desc: Test SetFrameNodeVisibility different argument.
1015  * @tc.type: FUNC
1016  */
1017 HWTEST_F(SelectOverlayTestNg, SetFrameNodeVisibility001, TestSize.Level1)
1018 {
1019     /**
1020      * @tc.steps: step1. Create and initialize selectOverlayNode and pattern.
1021      */
1022     SelectOverlayInfo selectInfo;
1023     selectInfo.menuInfo.menuDisable = true;
1024     selectInfo.menuInfo.showCut = false;
1025     selectInfo.menuInfo.showPaste = false;
1026     auto menuOptionItems = GetMenuOptionItems();
1027     selectInfo.menuOptionItems = menuOptionItems;
1028     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1029     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1030     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1031     EXPECT_NE(selectOverlayNode, nullptr);
1032     /**
1033      * @tc.steps: step2. Create default menu and extension menu .
1034      */
1035     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1036     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1037     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
1038     selectOverlayNode->CreateToolBar();
1039     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1040     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0370e02() 1041         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1042     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
1043     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<MenuTheme>()));
1044     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
1045     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
1046     EXPECT_NE(selectOverlayNode->extensionMenu_, nullptr);
1047     /**
1048      * @tc.steps: step3. call SetFrameNodeVisibility and pass different parameters .
1049      * @tc.expected: the corresponding value was successfully changed.
1050      */
1051     selectOverlayNode->SetFrameNodeVisibility(FrameNodeType::SELECTMENU, VisibleType::VISIBLE);
1052     selectOverlayNode->SetFrameNodeVisibility(FrameNodeType::EXTENSIONMENU, VisibleType::VISIBLE);
1053     selectOverlayNode->SetFrameNodeVisibility(FrameNodeType::BACKBUTTON, VisibleType::VISIBLE);
1054     EXPECT_EQ(selectOverlayNode->selectMenu_->GetLayoutProperty()->GetVisibility(), VisibleType::VISIBLE);
1055     EXPECT_EQ(selectOverlayNode->extensionMenu_->GetLayoutProperty()->GetVisibility(), VisibleType::VISIBLE);
1056     EXPECT_EQ(selectOverlayNode->backButton_->GetLayoutProperty()->GetVisibility(), VisibleType::VISIBLE);
1057 }
1058 
1059 /**
1060  * @tc.name: SetFrameNodeOpacity001
1061  * @tc.desc: Test SetFrameNodeOpacity different argument.
1062  * @tc.type: FUNC
1063  */
1064 HWTEST_F(SelectOverlayTestNg, SetFrameNodeOpacity001, TestSize.Level1)
1065 {
1066     /**
1067      * @tc.steps: step1. Create and initialize selectOverlayNode and pattern.
1068      */
1069     SelectOverlayInfo selectInfo;
1070     selectInfo.menuInfo.menuDisable = true;
1071     selectInfo.menuInfo.showCut = false;
1072     selectInfo.menuInfo.showPaste = false;
1073     auto menuOptionItems = GetMenuOptionItems();
1074     selectInfo.menuOptionItems = menuOptionItems;
1075     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1076     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1077     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1078     EXPECT_NE(selectOverlayNode, nullptr);
1079     /**
1080      * @tc.steps: step2. Create default menu and extension menu .
1081      */
1082     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1083     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1084     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
1085     selectOverlayNode->CreateToolBar();
1086     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1087     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0370f02() 1088         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1089     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
1090     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<MenuTheme>()));
1091     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
1092     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
1093     EXPECT_NE(selectOverlayNode->extensionMenu_, nullptr);
1094 
1095     /**
1096      * @tc.steps: step3. call SetFrameNodeOpacity and pass different parameters .
1097      * @tc.expected: the corresponding value was successfully changed.
1098      */
1099     selectOverlayNode->SetFrameNodeOpacity(FrameNodeType::SELECTMENU, 0.0);
1100     selectOverlayNode->SetFrameNodeOpacity(FrameNodeType::EXTENSIONMENU, 0.0);
1101     selectOverlayNode->SetFrameNodeOpacity(FrameNodeType::BACKBUTTON, 0.0);
1102 
1103     EXPECT_EQ(selectOverlayNode->selectMenu_->GetRenderContext()->GetOpacity(), 0.0);
1104     EXPECT_EQ(selectOverlayNode->extensionMenu_->GetRenderContext()->GetOpacity(), 0.0);
1105     EXPECT_EQ(selectOverlayNode->backButton_->GetRenderContext()->GetOpacity(), 0.0);
1106 }
1107 
1108 /**
1109  * @tc.name: ShowSelectOverlay001
1110  * @tc.desc: Test hasShowAnimation_ value change situation.
1111  * @tc.type: FUNC
1112  */
1113 HWTEST_F(SelectOverlayTestNg, ShowSelectOverlay001, TestSize.Level1)
1114 {
1115     /**
1116      * @tc.steps: step1. Create and initialize selectOverlayNode and pattern.
1117      */
1118     SelectOverlayInfo selectInfo;
1119     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1120     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1121     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1122     ASSERT_NE(selectOverlayNode, nullptr);
1123     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1124     ASSERT_NE(pattern, nullptr);
1125     bool animate[2] = { true, false };
1126     /**
1127      * @tc.steps: step2. call ShowSelectOverlay  .
1128      * @tc.expected: the hasShowAnimation_ value was successfully changed.
1129      */
1130     for (int i = 0; i < 2; i++) {
1131         selectOverlayNode->ShowSelectOverlay(animate[i]);
1132         EXPECT_EQ(pattern->hasShowAnimation_, animate[i]);
1133     }
1134 }
1135 
1136 /**
1137  * @tc.name: HideSelectOverlay001
1138  * @tc.desc: Test select_overlay_node HideSelectOverlay.
1139  * @tc.type: FUNC
1140  */
1141 HWTEST_F(SelectOverlayTestNg, HideSelectOverlay001, TestSize.Level1)
1142 {
1143     /**
1144      * @tc.steps: step1. Create and initialize selectOverlayNode and pattern.
1145      */
1146     SelectOverlayInfo selectInfo;
1147     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1148     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1149     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1150     ASSERT_NE(selectOverlayNode, nullptr);
1151     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1152     ASSERT_NE(pattern, nullptr);
1153     /**
1154      * @tc.steps: step2. call ShowSelectOverlay  .
1155      * @tc.expected: the circlesAndBackArrowOpacity_ value was successfully changed.
1156      */
1157     pattern->CreateNodePaintMethod();
1158     ASSERT_NE(pattern->selectOverlayModifier_, nullptr);
__anonede6c0371002() 1159     selectOverlayNode->HideSelectOverlay([]() {});
1160     EXPECT_EQ(pattern->selectOverlayModifier_->circlesAndBackArrowOpacity_->Get(), 0.0);
1161 }
1162 
1163 /**
1164  * @tc.name: UpdateToolBar001
1165  * @tc.desc: Test select_overlay_node UpdateToolBar.
1166  * @tc.type: FUNC
1167  */
1168 HWTEST_F(SelectOverlayTestNg, UpdateToolBar001, TestSize.Level1)
1169 {
1170     /**
1171      * @tc.steps: step1. Create and initialize selectOverlayNode and pattern six situation.
1172      */
1173     SelectOverlayInfo selectInfo;
1174     auto menuOptionItems = GetMenuOptionItems();
1175     selectInfo.menuOptionItems = menuOptionItems;
1176     for (int i = 0; i < 6; i++) {
1177         switch (i) {
1178             case 0:
1179             case 3:
1180                 selectInfo.menuInfo.menuDisable = true;
1181                 break;
1182             case 1:
1183             case 4:
1184                 selectInfo.menuInfo.menuDisable = false;
1185                 selectInfo.menuInfo.menuIsShow = true;
1186                 break;
1187             case 2:
1188             case 6:
1189                 selectInfo.menuInfo.menuDisable = false;
1190                 selectInfo.menuInfo.menuIsShow = false;
1191                 break;
1192             default:
1193                 break;
1194         }
1195 
1196         auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1197         auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1198         auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1199         ASSERT_NE(selectOverlayNode, nullptr);
1200         selectOverlayNode->isExtensionMenu_ = true;
1201         selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
1202         selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0371102() 1203             ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1204         if (i < 3) {
1205             selectOverlayNode->selectMenuStatus_ = FrameNodeStatus::VISIBLETOGONE;
1206             selectOverlayNode->extensionMenuStatus_ = FrameNodeStatus::GONETOVISIBLE;
1207             selectOverlayNode->backButtonStatus_ = FrameNodeStatus::GONETOVISIBLE;
1208         }
1209         EXPECT_NE(selectOverlayNode->backButton_, nullptr);
1210         EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
1211         auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1212         ASSERT_NE(pattern, nullptr);
1213         auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1214         MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1215         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
1216         selectOverlayNode->CreateToolBar();
1217         /**
1218          * @tc.steps: step3. call UpdateToolBar for call the other function .
1219          * @tc.expected: the isExtensionMenu_ value was successfully changed.
1220          */
1221         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1222         selectOverlayNode->UpdateToolBar(false);
1223 
1224         EXPECT_TRUE(selectOverlayNode->isExtensionMenu_);
1225 
1226         selectOverlayNode->UpdateToolBar(true);
1227 
1228         EXPECT_FALSE(selectOverlayNode->isExtensionMenu_);
1229     }
1230 }
1231 
1232 /**
1233  * @tc.name: ContentModifierOnDraw001
1234  * @tc.desc: Test select_ovelay_content_modifier onDraw.
1235  * @tc.type: FUNC
1236  */
1237 HWTEST_F(SelectOverlayTestNg, ContentModifierOnDraw001, TestSize.Level1)
1238 {
1239     /**
1240      * @tc.steps: step1. Create selectOverlayNode, pattern,canvs
1241      * and initialize properties.
1242      */
1243     SelectOverlayInfo selectInfo;
1244     selectInfo.menuInfo.menuDisable = true;
1245     selectInfo.menuInfo.showCut = false;
1246     selectInfo.menuInfo.showPaste = false;
1247     auto menuOptionItems = GetMenuOptionItems();
1248     selectInfo.menuOptionItems = menuOptionItems;
1249     selectInfo.singleLineHeight = NODE_ID;
1250     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1251     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1252     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1253     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1254     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1255     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1256     EXPECT_NE(selectOverlayNode, nullptr);
1257     selectOverlayNode->CreateToolBar();
1258     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1259     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0371202() 1260         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1261     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
1262     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<MenuTheme>()));
1263     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
1264     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
1265     EXPECT_NE(selectOverlayNode->extensionMenu_, nullptr);
1266     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1267     EXPECT_NE(pattern, nullptr);
1268     RefPtr<NodePaintMethod> paintMethod = pattern->CreateNodePaintMethod();
1269     EXPECT_NE(paintMethod, nullptr);
1270     paintMethod = pattern->CreateNodePaintMethod();
1271     EXPECT_NE(paintMethod, nullptr);
1272     auto selectOverlayPaintMethod = AceType::DynamicCast<SelectOverlayPaintMethod>(paintMethod);
1273     EXPECT_NE(selectOverlayPaintMethod, nullptr);
1274     auto contentModifier = pattern->selectOverlayContentModifier_;
1275     auto overlayModifier = pattern->selectOverlayModifier_;
1276     EXPECT_NE(contentModifier, nullptr);
1277     EXPECT_NE(overlayModifier, nullptr);
1278     Testing::MockCanvas canvas;
1279     EXPECT_CALL(canvas, Save()).Times(AtLeast(1));
1280     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1281     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
1282     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1283     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
1284     EXPECT_CALL(canvas, DrawCircle(_, _)).Times(AtLeast(1));
1285     EXPECT_CALL(canvas, Translate(_, _)).Times(AtLeast(1));
1286     EXPECT_CALL(canvas, Restore()).Times(AtLeast(1));
1287     EXPECT_CALL(canvas, ClipRect(_, _, _)).WillRepeatedly(Return());
1288     EXPECT_CALL(canvas, DrawLine(_, _)).Times(AtLeast(1));
1289     DrawingContext context { canvas, 100, 100 };
1290     /**
1291      * @tc.steps: step2. get the contentModifier and initialize properies and call onDraw function.
1292      * @tc.expected: the innerHandleRadius_ value is correct.
1293      */
1294     contentModifier->SetIsSingleHandle(true);
1295     contentModifier->SetFirstHandleIsShow(true);
1296     contentModifier->SetInShowArea(true);
1297     EXPECT_EQ(contentModifier->inShowArea_->Get(), true);
1298     contentModifier->SetHandleReverse(false);
1299     EXPECT_EQ(contentModifier->handleReverse_->Get(), false);
1300     contentModifier->SetViewPort(SECOND_HANDLE_REGION);
1301     EXPECT_EQ(contentModifier->viewPort_->Get(), SECOND_HANDLE_REGION);
1302     contentModifier->SetFirstHandle(SECOND_HANDLE_REGION);
1303     EXPECT_EQ(contentModifier->firstHandle_->Get(), SECOND_HANDLE_REGION);
1304     contentModifier->SetSecondHandle(SECOND_HANDLE_REGION);
1305     EXPECT_EQ(contentModifier->secondHandle_->Get(), SECOND_HANDLE_REGION);
1306     contentModifier->SetHandleColor(Color::RED);
1307     EXPECT_EQ(contentModifier->handleColor_->Get(), Color::RED);
1308     contentModifier->SetInnerHandleColor(Color::RED);
1309     EXPECT_EQ(contentModifier->innerHandleColor_->Get(), Color::RED);
1310     contentModifier->SetHandleRadius(2.0f);
1311     EXPECT_EQ(contentModifier->handleRadius_->Get(), 2.0f);
1312     contentModifier->SetInnerHandleRadius(2.0f);
1313     EXPECT_EQ(contentModifier->innerHandleRadius_->Get(), 2.0f);
1314     contentModifier->SetHandleOpacity(2.0f);
1315     EXPECT_EQ(contentModifier->handleOpacity_->Get(), 2.0f);
1316     for (int i = 0; i < 6; i++) {
1317         switch (i) {
1318             case 0:
1319                 contentModifier->SetFirstHandleIsShow(true);
1320                 EXPECT_EQ(contentModifier->firstHandleIsShow_->Get(), true);
1321                 break;
1322             case 1:
1323                 contentModifier->SetIsSingleHandle(true);
1324                 EXPECT_EQ(contentModifier->isSingleHandle_->Get(), true);
1325                 contentModifier->SetFirstHandleIsShow(false);
1326                 EXPECT_EQ(contentModifier->firstHandleIsShow_->Get(), false);
1327                 contentModifier->SetSecondHandleIsShow(true);
1328                 EXPECT_EQ(contentModifier->secondHandleIsShow_->Get(), true);
1329                 break;
1330             case 2:
1331                 contentModifier->SetIsSingleHandle(false);
1332                 EXPECT_EQ(contentModifier->isSingleHandle_->Get(), false);
1333                 contentModifier->SetFirstHandleIsShow(true);
1334                 EXPECT_EQ(contentModifier->firstHandleIsShow_->Get(), true);
1335                 break;
1336             case 3:
1337                 contentModifier->SetIsSingleHandle(true);
1338                 EXPECT_EQ(contentModifier->isSingleHandle_->Get(), true);
1339                 contentModifier->SetFirstHandleIsShow(false);
1340                 EXPECT_EQ(contentModifier->firstHandleIsShow_->Get(), false);
1341                 contentModifier->SetSecondHandleIsShow(false);
1342                 EXPECT_EQ(contentModifier->secondHandleIsShow_->Get(), false);
1343                 break;
1344             case 4:
1345                 contentModifier->SetIsSingleHandle(false);
1346                 EXPECT_EQ(contentModifier->isSingleHandle_->Get(), false);
1347                 break;
1348             case 5:
1349                 contentModifier->SetInShowArea(false);
1350                 EXPECT_EQ(contentModifier->inShowArea_->Get(), false);
1351                 break;
1352             default:
1353                 break;
1354         }
1355 
1356         contentModifier->onDraw(context);
1357     }
1358     EXPECT_EQ(contentModifier->innerHandleRadius_->Get(), 2.0f);
1359 }
1360 
1361 /**
1362  * @tc.name: ContentModifierOnDraw002
1363  * @tc.desc: Test select_ovelay_content_modifier onDraw.
1364  * @tc.type: FUNC
1365  */
1366 HWTEST_F(SelectOverlayTestNg, ContentModifierOnDraw002, TestSize.Level1)
1367 {
1368     /**
1369      * @tc.steps: step1. Create selectOverlayNode, pattern, canvas, context
1370      * and initialize properties.
1371     */
1372     SelectOverlayInfo selectInfo;
1373     selectInfo.menuInfo.menuDisable = true;
1374     selectInfo.menuInfo.showCut = false;
1375     selectInfo.menuInfo.showPaste = false;
1376     auto menuOptionItems = GetMenuOptionItems();
1377     selectInfo.menuOptionItems = menuOptionItems;
1378     selectInfo.singleLineHeight = NODE_ID;
1379     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1380     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1381     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1382     ASSERT_NE(selectOverlayNode, nullptr);
1383     selectOverlayNode->CreateToolBar();
1384     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1385     ASSERT_NE(pattern, nullptr);
1386     pattern->CreateNodePaintMethod();
1387     auto contentModifier = pattern->selectOverlayContentModifier_;
1388     EXPECT_NE(contentModifier, nullptr);
1389 
1390     /**
1391      * @tc.steps: step2. set param and call onDraw function.
1392      */
1393     Testing::MockCanvas canvas;
1394     DrawingContext context { canvas, 100, 100 };
1395     contentModifier->isUsingMouse_ = false;
1396     contentModifier->SetIsHiddenHandle(true);
1397     contentModifier->onDraw(context);
1398     EXPECT_EQ(contentModifier->isHiddenHandle_->Get(), true);
1399 }
1400 
1401 /**
1402  * @tc.name: ContentModifierOnDraw003
1403  * @tc.desc: Test select_ovelay_content_modifier onDraw.
1404  * @tc.type: FUNC
1405  */
1406 HWTEST_F(SelectOverlayTestNg, ContentModifierOnDraw003, TestSize.Level1)
1407 {
1408     /**
1409      * @tc.steps: step1. Create selectOverlayNode, pattern,canvs
1410      * and initialize properties.
1411      */
1412     SelectOverlayInfo selectInfo;
1413     selectInfo.menuInfo.menuDisable = true;
1414     selectInfo.menuInfo.showCut = false;
1415     selectInfo.menuInfo.showPaste = false;
1416     auto menuOptionItems = GetMenuOptionItems();
1417     selectInfo.menuOptionItems = menuOptionItems;
1418     selectInfo.singleLineHeight = NODE_ID;
1419     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1420     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1421     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1422     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1423     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1424     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1425     EXPECT_NE(selectOverlayNode, nullptr);
1426     selectOverlayNode->CreateToolBar();
1427     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1428     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0371302() 1429         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1430     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
1431     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
1432     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
1433     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1434     EXPECT_NE(pattern, nullptr);
1435     RefPtr<NodePaintMethod> paintMethod = pattern->CreateNodePaintMethod();
1436     EXPECT_NE(paintMethod, nullptr);
1437     paintMethod = pattern->CreateNodePaintMethod();
1438     EXPECT_NE(paintMethod, nullptr);
1439     auto selectOverlayPaintMethod = AceType::DynamicCast<SelectOverlayPaintMethod>(paintMethod);
1440     EXPECT_NE(selectOverlayPaintMethod, nullptr);
1441     auto contentModifier = pattern->selectOverlayContentModifier_;
1442     EXPECT_NE(contentModifier, nullptr);
1443     Testing::MockCanvas canvas;
1444     EXPECT_CALL(canvas, Save()).Times(AtLeast(1));
1445     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1446     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
1447     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1448     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
1449     EXPECT_CALL(canvas, Restore()).Times(AtLeast(1));
1450     EXPECT_CALL(canvas, ClipRect(_, _, _)).WillRepeatedly(Return());
1451     DrawingContext context { canvas, 100, 100 };
1452     /**
1453      * @tc.steps: step3. set param and call onDraw function.
1454      */
1455     contentModifier->isUsingMouse_ = false;
1456     contentModifier->SetIsHiddenHandle(false);
1457     contentModifier->SetInShowArea(true);
1458     contentModifier->SetIsSingleHandle(false);
1459     contentModifier->SetHandleReverse(true);
1460     contentModifier->onDraw(context);
1461     EXPECT_EQ(contentModifier->isHiddenHandle_->Get(), false);
1462 }
1463 
1464 /**
1465  * @tc.name: ContentModifierOnDraw004
1466  * @tc.desc: Test select_ovelay_content_modifier onDraw.
1467  * @tc.type: FUNC
1468  */
1469 HWTEST_F(SelectOverlayTestNg, ContentModifierOnDraw004, TestSize.Level1)
1470 {
1471     /**
1472      * @tc.steps: step1. Create selectOverlayNode, pattern,canvs
1473      * and initialize properties.
1474      */
1475     SelectOverlayInfo selectInfo;
1476     selectInfo.menuInfo.menuDisable = true;
1477     selectInfo.menuInfo.showCut = false;
1478     selectInfo.menuInfo.showPaste = false;
1479     selectInfo.singleLineHeight = NODE_ID;
1480     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1481     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1482     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1483     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1484     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1485     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1486     EXPECT_NE(selectOverlayNode, nullptr);
1487     selectOverlayNode->CreateToolBar();
1488     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1489     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1490     EXPECT_NE(pattern, nullptr);
1491     pattern->CreateNodePaintMethod();
1492     auto contentModifier = pattern->selectOverlayContentModifier_;
1493     EXPECT_NE(contentModifier, nullptr);
1494     Testing::MockCanvas canvas;
1495     EXPECT_CALL(canvas, Save()).Times(AtLeast(1));
1496     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1497     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
1498     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1499     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
1500     EXPECT_CALL(canvas, DrawCircle(_, _)).Times(AtLeast(1));
1501     EXPECT_CALL(canvas, Translate(_, _)).Times(AtLeast(1));
1502     EXPECT_CALL(canvas, Restore()).Times(AtLeast(1));
1503     EXPECT_CALL(canvas, ClipRect(_, _, _)).WillRepeatedly(Return());
1504     EXPECT_CALL(canvas, DrawLine(_, _)).Times(AtLeast(1));
1505     contentModifier->isUsingMouse_ = false;
1506     contentModifier->SetIsHiddenHandle(false);
1507     contentModifier->SetInShowArea(true);
1508 
1509     /**
1510      * @tc.steps: step2. set param and call PaintSingleHandle function
1511     */
1512     contentModifier->isPaintHandleUsePoints_ = true;
1513     contentModifier->SetIsSingleHandle(true);
1514     contentModifier->firstHandlePaintInfo_.width = 6.0f;
1515     contentModifier->firstHandleIsShow_->Set(true);
1516     contentModifier->secondHandlePaintInfo_.width = 6.0f;
1517     contentModifier->secondHandleIsShow_->Set(true);
1518     contentModifier->PaintSingleHandle(canvas);
1519     EXPECT_EQ(contentModifier->isPaintHandleUsePoints_, true);
1520 
1521     /**
1522      * @tc.steps: step3. set param and call PaintSingleHandle function
1523     */
1524     contentModifier->isPaintHandleUsePoints_ = true;
1525     contentModifier->SetIsSingleHandle(false);
1526     contentModifier->SetFirstHandleIsShow(true);
1527     contentModifier->SetSecondHandleIsShow(true);
1528     contentModifier->PaintDoubleHandle(canvas);
1529     EXPECT_EQ(contentModifier->isPaintHandleUsePoints_, true);
1530 }
1531 
1532 /**
1533  * @tc.name: OverlayModifierOnDraw001
1534  * @tc.desc: Test select_ovelay_modifier onDraw.
1535  * @tc.type: FUNC
1536  */
1537 HWTEST_F(SelectOverlayTestNg, OverlayModifierOnDraw001, TestSize.Level1)
1538 {
1539     /**
1540      * @tc.steps: step1. Create selectOverlayNode, pattern,canvs
1541      * and initialize properties.
1542      */
1543     SelectOverlayInfo selectInfo;
1544     selectInfo.menuInfo.menuDisable = true;
1545     selectInfo.menuInfo.showCut = false;
1546     selectInfo.menuInfo.showPaste = false;
1547     auto menuOptionItems = GetMenuOptionItems();
1548     selectInfo.menuOptionItems = menuOptionItems;
1549     selectInfo.singleLineHeight = NODE_ID;
1550     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1551     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1552     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1553     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1554     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1555     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1556     EXPECT_NE(selectOverlayNode, nullptr);
1557     selectOverlayNode->CreateToolBar();
1558     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1559     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
1560     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0371402() 1561         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1562     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
1563     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<MenuTheme>()));
1564     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
1565     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
1566     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1567     EXPECT_NE(pattern, nullptr);
1568     RefPtr<NodePaintMethod> paintMethod = pattern->CreateNodePaintMethod();
1569     EXPECT_NE(paintMethod, nullptr);
1570     paintMethod = pattern->CreateNodePaintMethod();
1571     EXPECT_NE(paintMethod, nullptr);
1572     auto selectOverlayPaintMethod = AceType::DynamicCast<SelectOverlayPaintMethod>(paintMethod);
1573     EXPECT_NE(selectOverlayPaintMethod, nullptr);
1574     auto overlayModifier = pattern->selectOverlayModifier_;
1575     EXPECT_NE(overlayModifier, nullptr);
1576     Testing::MockCanvas canvas;
1577     DrawingContext context = GetDrawingContext(canvas);
1578     for (int32_t i = 0; i < 4; i++) {
1579         overlayModifier->circleOffset_[i] = AceType::MakeRefPtr<AnimatablePropertyOffsetF>(offset);
1580         EXPECT_NE(overlayModifier->circleOffset_[i], nullptr);
1581         if (i < 4 - 1) {
1582             overlayModifier->lineEndOffset_[i] = AceType::MakeRefPtr<AnimatablePropertyOffsetF>(offset);
1583             EXPECT_NE(overlayModifier->lineEndOffset_[i], nullptr);
1584         }
1585     }
1586     overlayModifier->rotationAngle_ = AceType::MakeRefPtr<AnimatablePropertyFloat>(Dimension(1.75_vp).ConvertToPx());
1587     overlayModifier->SetMenuOptionOffset(offset);
1588     overlayModifier->pointRadius_ = AceType::MakeRefPtr<AnimatablePropertyFloat>(Dimension(1.75_vp).ConvertToPx());
1589     overlayModifier->SetHeadPointRadius(Dimension(1.0));
1590     /**
1591      * @tc.steps: step2. call onDraw.
1592      * @tc.expected: the menuOptionOffset_ value is correct.
1593      */
1594     overlayModifier->onDraw(context);
1595     EXPECT_EQ(overlayModifier->hasExtensionMenu_->Get(), false);
1596 }
1597 
1598 /**
1599  * @tc.name: SelectOverlayLayout002
1600  * @tc.desc: Test selectOverlay layout when checkIsInShowArea is false.
1601  * @tc.type: FUNC
1602  */
1603 HWTEST_F(SelectOverlayTestNg, SelectOverlayLayout002, TestSize.Level1)
1604 {
1605     /**
1606      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
1607      */
1608     SelectOverlayInfo selectInfo;
1609     selectInfo.singleLineHeight = NODE_ID;
1610     selectInfo.menuOptionItems = GetMenuOptionItems();
1611     selectInfo.menuInfo.menuIsShow = true;
1612     selectInfo.useFullScreen = false;
1613     bool isSingleHandle[2] = { false, true };
1614     for (int i = 0; i < 2; i++) {
1615         selectInfo.isSingleHandle = isSingleHandle[i];
1616         selectInfo.firstHandle.paintRect = FIRST_HANDLE_REGION;
1617         selectInfo.secondHandle.paintRect = SECOND_HANDLE_REGION;
1618         selectInfo.showArea = FIRST_HANDLE_REGION;
1619         auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1620         MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1621         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1622         auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1623         auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1624         auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1625         ASSERT_NE(selectOverlayNode, nullptr);
1626         /**
1627          * @tc.steps: step2. Create pattern and geometryNode.
1628          */
1629         auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1630         ASSERT_NE(pattern, nullptr);
1631         RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1632         /**
1633          * @tc.steps: step3. Get layoutWrapper and layoutAlgorithm.
1634          * @tc.expected: layoutWrapper and layoutAlgorithm are created successfully
1635          */
1636         LayoutWrapperNode* layoutWrapper =
1637             new LayoutWrapperNode(frameNode, geometryNode, frameNode->GetLayoutProperty());
1638         auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
1639         ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
1640         layoutWrapper->SetLayoutAlgorithm(
1641             AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
1642 
1643         auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
1644         childLayoutConstraint.selfIdealSize = OptionalSizeF(FIRST_ITEM_SIZE);
1645         // create menu
1646         auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0371502() 1647             V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "Test", TYPE); });
1648         // add item to selectOverlayNode
1649         selectOverlayNode->AddChild(item);
1650         RefPtr<GeometryNode> itemGeometryNode = AceType::MakeRefPtr<GeometryNode>();
1651         itemGeometryNode->Reset();
1652         RefPtr<LayoutWrapperNode> itemLayoutWrapper =
1653             AceType::MakeRefPtr<LayoutWrapperNode>(item, itemGeometryNode, item->GetLayoutProperty());
1654         EXPECT_FALSE(itemLayoutWrapper == nullptr);
1655         auto itemPattern = item->GetPattern<MenuPattern>();
1656         EXPECT_FALSE(itemPattern == nullptr);
1657         itemLayoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(childLayoutConstraint);
1658         auto itemLayoutAlgorithm = itemPattern->CreateLayoutAlgorithm();
1659         EXPECT_FALSE(itemLayoutAlgorithm == nullptr);
1660         itemLayoutWrapper->SetLayoutAlgorithm(
1661             AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(itemLayoutAlgorithm));
1662         itemLayoutWrapper->GetLayoutProperty()->UpdateUserDefinedIdealSize(
1663             CalcSize(CalcLength(FIRST_ITEM_WIDTH), CalcLength(FIRST_ITEM_HEIGHT)));
1664         layoutWrapper->AppendChild(itemLayoutWrapper);
1665         /**
1666          * @tc.steps: step4. use layoutAlgorithm to measure and layout.
1667          * @tc.expected: RemoveChildInRenderTree is executed successfully when checkIsInShowArea is false.
1668          */
1669         EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
1670         selectOverlayLayoutAlgorithm->Layout(layoutWrapper);
1671         EXPECT_FALSE(layoutWrapper->isActive_);
1672     }
1673 }
1674 
1675 /**
1676  * @tc.name: IsMenuShow001
1677  * @tc.desc: Test IsMenuShow function.
1678  * @tc.type: FUNC
1679  */
1680 HWTEST_F(SelectOverlayTestNg, IsMenuShow001, TestSize.Level1)
1681 {
1682     /**
1683      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1684      */
1685     SelectOverlayInfo selectInfo;
1686     selectInfo.menuOptionItems = GetMenuOptionItems();
1687     selectInfo.singleLineHeight = NODE_ID;
1688     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1689     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1690     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1691     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1692     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1693     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1694     ASSERT_NE(selectOverlayNode, nullptr);
1695     /**
1696      * @tc.steps: step2. Create pattern and call IsMenuShow function.
1697      * @tc.expected: The isMenuShow returns false
1698      */
1699     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1700     ASSERT_NE(pattern, nullptr);
1701     EXPECT_FALSE(pattern->IsMenuShow());
1702 }
1703 
1704 /**
1705  * @tc.name: IsHandleShow001
1706  * @tc.desc: Test IsHandleShow function.
1707  * @tc.type: FUNC
1708  */
1709 HWTEST_F(SelectOverlayTestNg, IsHandleShow001, TestSize.Level1)
1710 {
1711     /**
1712      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1713      */
1714     SelectOverlayInfo selectInfo;
1715     selectInfo.menuOptionItems = GetMenuOptionItems();
1716     selectInfo.singleLineHeight = NODE_ID;
1717     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1718     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1719     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1720     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1721     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1722     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1723     ASSERT_NE(selectOverlayNode, nullptr);
1724     /**
1725      * @tc.steps: step2. Create pattern and call IsHandleShow function.
1726      * @tc.expected: The IsHandleShow returns true.
1727      */
1728     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1729     ASSERT_NE(pattern, nullptr);
1730     EXPECT_TRUE(pattern->IsHandleShow());
1731 }
1732 
1733 /**
1734  * @tc.name: StartHiddenHandleTask001
1735  * @tc.desc: Test StartHiddenHandleTask function.
1736  * @tc.type: FUNC
1737  */
1738 HWTEST_F(SelectOverlayTestNg, StartHiddenHandleTask001, TestSize.Level1)
1739 {
1740     /**
1741      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1742      */
1743     SelectOverlayInfo selectInfo;
1744     selectInfo.menuOptionItems = GetMenuOptionItems();
1745     selectInfo.singleLineHeight = NODE_ID;
1746     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1747     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1748     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1749     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1750     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1751     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1752     ASSERT_NE(selectOverlayNode, nullptr);
1753     auto taskExecutor = AceType::MakeRefPtr<MockTaskExecutor>();
1754     ASSERT_NE(taskExecutor, nullptr);
1755     auto pipeline = PipelineBase::GetCurrentContext();
1756     pipeline->taskExecutor_ = taskExecutor;
1757     /**
1758      * @tc.steps: step2. Create pattern and call StartHiddenHandleTask function.
1759      */
1760     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1761     ASSERT_NE(pattern, nullptr);
1762     pattern->StartHiddenHandleTask();
1763 }
1764 
1765 /**
1766  * @tc.name: HiddenHandle001
1767  * @tc.desc: Test HiddenHandle function.
1768  * @tc.type: FUNC
1769  */
1770 HWTEST_F(SelectOverlayTestNg, HiddenHandle001, TestSize.Level1)
1771 {
1772     /**
1773      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1774      */
1775     SelectOverlayInfo selectInfo;
1776     selectInfo.menuOptionItems = GetMenuOptionItems();
1777     selectInfo.singleLineHeight = NODE_ID;
1778     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1779     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1780     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1781     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1782     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1783     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1784     ASSERT_NE(selectOverlayNode, nullptr);
1785     /**
1786      * @tc.steps: step2. Create pattern and call HiddenHandle function.
1787      * @tc.expected: The selectInfo->isHiddenHandle_ value is true
1788      */
1789     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1790     ASSERT_NE(pattern, nullptr);
1791     pattern->isHiddenHandle_ = false;
1792     pattern->HiddenHandle();
1793     EXPECT_TRUE(pattern->isHiddenHandle_);
1794 }
1795 
1796 /**
1797  * @tc.name: StopHiddenHandleTask001
1798  * @tc.desc: Test StopHiddenHandleTask function.
1799  * @tc.type: FUNC
1800  */
1801 HWTEST_F(SelectOverlayTestNg, StopHiddenHandleTask001, TestSize.Level1)
1802 {
1803     /**
1804      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1805      */
1806     SelectOverlayInfo selectInfo;
1807     selectInfo.menuOptionItems = GetMenuOptionItems();
1808     selectInfo.singleLineHeight = NODE_ID;
1809     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1810     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1811     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1812     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1813     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1814     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1815     ASSERT_NE(selectOverlayNode, nullptr);
1816     /**
1817      * @tc.steps: step2. Create pattern and call StopHiddenHandleTask function.
1818      */
1819     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1820     ASSERT_NE(pattern, nullptr);
1821     pattern->StopHiddenHandleTask();
1822 }
1823 
1824 /**
1825  * @tc.name: OnDetachFromFrameNode001
1826  * @tc.desc: Test OnDetachFromFrameNodee function.
1827  * @tc.type: FUNC
1828  */
1829 HWTEST_F(SelectOverlayTestNg, OnDetachFromFrameNode001, TestSize.Level1)
1830 {
1831     /**
1832      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1833      */
1834     SelectOverlayInfo selectInfo;
1835     selectInfo.menuOptionItems = GetMenuOptionItems();
1836     selectInfo.singleLineHeight = NODE_ID;
__anonede6c0371602(bool closedByGlobalTouchEvent_) 1837     auto testCallback = [](bool closedByGlobalTouchEvent_) {
1838         callBackFlag = static_cast<int32_t>(closedByGlobalTouchEvent_);
1839         return;
1840     };
1841     selectInfo.onClose = testCallback;
1842     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1843     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1844     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1845     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1846     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1847     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1848     ASSERT_NE(selectOverlayNode, nullptr);
1849 
1850     /**
1851      * @tc.steps: step2. Create pattern and call OnDetachFromFrameNode function.
1852      */
1853     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1854     ASSERT_NE(pattern, nullptr);
1855     pattern->OnDetachFromFrameNode(
__anonede6c0371702() 1856         FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton", ElementRegister::GetInstance()->MakeUniqueId(), []() {
1857             return AceType::MakeRefPtr<ButtonPattern>();
1858         }).rawPtr_);
1859     EXPECT_FALSE(pattern->closedByGlobalTouchEvent_);
1860     EXPECT_EQ(callBackFlag, 0);
1861 }
1862 
1863 /**
1864  * @tc.name: SetHandleReverse001
1865  * @tc.desc: Test SetHandleReverse function.
1866  * @tc.type: FUNC
1867  */
1868 HWTEST_F(SelectOverlayTestNg, SetHandleReverse001, TestSize.Level1)
1869 {
1870     /**
1871      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1872      */
1873     SelectOverlayInfo selectInfo;
1874     selectInfo.menuOptionItems = GetMenuOptionItems();
1875     selectInfo.singleLineHeight = NODE_ID;
1876     selectInfo.menuInfo.menuDisable = false;
1877     selectInfo.isSingleHandle = false;
1878     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1879     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1880     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1881     ASSERT_NE(selectOverlayNode, nullptr);
1882     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1883     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1884     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
1885     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1886 
1887     /**
1888      * @tc.steps: step2. Create pattern and call SetHandleReverse function.
1889      */
1890     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1891     ASSERT_NE(pattern, nullptr);
1892     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
1893     pattern->info_->handleReverse = true;
1894     pattern->SetHandleReverse(true);
1895     EXPECT_TRUE(pattern->info_->handleReverse);
1896     pattern->SetHandleReverse(false);
1897     EXPECT_FALSE(pattern->info_->handleReverse);
1898 }
1899 
1900 /**
1901  * @tc.name: UpdateSelectMenuInfo001
1902  * @tc.desc: Test UpdateSelectMenuInfo function.
1903  * @tc.type: FUNC
1904  */
1905 HWTEST_F(SelectOverlayTestNg, UpdateSelectMenuInfo001, TestSize.Level1)
1906 {
1907     /**
1908      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1909      */
1910     SelectOverlayInfo selectInfo;
1911     selectInfo.menuOptionItems = GetMenuOptionItems();
1912     selectInfo.singleLineHeight = NODE_ID;
1913     selectInfo.menuInfo.menuDisable = false;
1914     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1915     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1916     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1917     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1918     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1919     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1920     ASSERT_NE(selectOverlayNode, nullptr);
1921 
1922     /**
1923      * @tc.steps: step2. Create pattern and call UpdateSelectMenuInfo function.
1924      */
1925     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1926     ASSERT_NE(pattern, nullptr);
1927     SelectMenuInfo infoMenu;
1928     OffsetF testCase(4, 5);
1929     infoMenu.menuOffset = testCase;
1930     pattern->UpdateSelectMenuInfo(infoMenu);
1931     EXPECT_EQ(pattern->info_->menuInfo.menuOffset, testCase);
1932 }
1933 
1934 /**
1935  * @tc.name: ShowOrHiddenMenu001
1936  * @tc.desc: Test ShowOrHiddenMenu function.
1937  * @tc.type: FUNC
1938  */
1939 HWTEST_F(SelectOverlayTestNg, ShowOrHiddenMenu001, TestSize.Level1)
1940 {
1941     /**
1942      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1943      */
1944     SelectOverlayInfo selectInfo;
1945     selectInfo.menuOptionItems = GetMenuOptionItems();
1946     selectInfo.singleLineHeight = NODE_ID;
1947     selectInfo.menuInfo.menuDisable = false;
1948     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1949     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1950     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1951     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1952     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1953     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
1954     ASSERT_NE(selectOverlayNode, nullptr);
1955 
1956     /**
1957      * @tc.steps: step2. Create pattern and call ShowOrHiddenMenu function.
1958      */
1959     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
1960     ASSERT_NE(pattern, nullptr);
1961     for (int i = 0; i < 2; ++i) {
1962         bool isHidden = i;
1963         for (int j = 0; j < 2; ++j) {
1964             infoPtr->menuInfo.menuIsShow = j;
1965             for (int k = 0; k < 4; ++k) {
1966                 infoPtr->firstHandle.isShow = k & 1;
1967                 infoPtr->secondHandle.isShow = k >> 1 & 1;
1968                 pattern->ShowOrHiddenMenu(isHidden);
1969                 if (infoPtr->menuInfo.menuIsShow && isHidden) {
1970                     EXPECT_FALSE(pattern->info_->menuInfo.menuIsShow);
1971                 } else if (!infoPtr->menuInfo.menuIsShow && !isHidden &&
1972                            (infoPtr->firstHandle.isShow || infoPtr->secondHandle.isShow)) {
1973                     EXPECT_TRUE(pattern->info_->menuInfo.menuIsShow);
1974                 }
1975             }
1976         }
1977     }
1978 }
1979 
1980 /**
1981  * @tc.name: DisableMenu001
1982  * @tc.desc: Test DisableMenu function.
1983  * @tc.type: FUNC
1984  */
1985 HWTEST_F(SelectOverlayTestNg, DisableMenu001, TestSize.Level1)
1986 {
1987     /**
1988      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
1989      */
1990     SelectOverlayInfo selectInfo;
1991     selectInfo.menuOptionItems = GetMenuOptionItems();
1992     selectInfo.singleLineHeight = NODE_ID;
1993     selectInfo.menuInfo.menuDisable = false;
1994     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1995     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1996     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1997     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
1998     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
1999     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2000     ASSERT_NE(selectOverlayNode, nullptr);
2001 
2002     /**
2003      * @tc.steps: step2. Create pattern and call DisableMenu function.
2004      */
2005     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2006     ASSERT_NE(pattern, nullptr);
2007     std::vector<bool> testCases = { true, false };
2008     for (uint32_t turn = 0; turn < testCases.size(); ++turn) {
2009         pattern->DisableMenu(testCases[turn]);
2010         EXPECT_EQ(pattern->info_->menuInfo.menuDisable, testCases[turn]);
2011     }
2012 }
2013 
2014 /**
2015  * @tc.name: SetClosedByGlobalEvent001
2016  * @tc.desc: Test SetClosedByGlobalEvent function.
2017  * @tc.type: FUNC
2018  */
2019 HWTEST_F(SelectOverlayTestNg, SetClosedByGlobalEvent001, TestSize.Level1)
2020 {
2021     /**
2022      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
2023      */
2024     SelectOverlayInfo selectInfo;
2025     selectInfo.menuInfo.menuDisable = true;
2026     selectInfo.menuInfo.showCut = false;
2027     selectInfo.menuInfo.showPaste = false;
2028     auto menuOptionItems = GetMenuOptionItems();
2029     selectInfo.menuOptionItems = menuOptionItems;
2030     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2031     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2032     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2033     EXPECT_NE(selectOverlayNode, nullptr);
2034 
2035     /**
2036      * @tc.steps: step2. Create pattern and call SetClosedByGlobalEvent function.
2037      */
2038     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2039     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2040     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
2041     selectOverlayNode->CreateToolBar();
2042     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2043     selectOverlayNode->SetClosedByGlobalEvent(true);
2044     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2045     ASSERT_NE(pattern, nullptr);
2046     EXPECT_TRUE(pattern->closedByGlobalTouchEvent_);
2047 }
2048 
2049 /**
2050  * @tc.name: UpdateToolBar002
2051  * @tc.desc: Test select_overlay_node UpdateToolBar.
2052  * @tc.type: FUNC
2053  */
2054 HWTEST_F(SelectOverlayTestNg, UpdateToolBar002, TestSize.Level1)
2055 {
2056     /**
2057      * @tc.steps: step1. Create and initialize selectOverlayNode and pattern six situation.
2058      */
2059     SelectOverlayInfo selectInfo;
2060     auto menuOptionItems = GetMenuOptionItems();
2061     selectInfo.menuOptionItems = menuOptionItems;
2062     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2063     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2064     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2065     ASSERT_NE(selectOverlayNode, nullptr);
2066     selectOverlayNode->isExtensionMenu_ = true;
2067     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2068     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2069     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<MenuTheme>()));
2070     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
2071 
2072     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
2073     selectOverlayNode->CreateToolBar();
2074     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2075 
2076     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0371802() 2077         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
2078     selectOverlayNode->selectMenuStatus_ = FrameNodeStatus::VISIBLETOGONE;
2079     selectOverlayNode->extensionMenuStatus_ = FrameNodeStatus::GONETOVISIBLE;
2080     selectOverlayNode->backButtonStatus_ = FrameNodeStatus::GONETOVISIBLE;
2081     ASSERT_NE(selectOverlayNode->backButton_, nullptr);
2082     ASSERT_NE(selectOverlayNode->selectMenu_, nullptr);
2083 
2084     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2085     ASSERT_NE(pattern, nullptr);
2086     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
__anonede6c0371902() 2087     infoPtr->menuCallback.onCut = []() {
2088         callBackFlag = 1;
2089         return;
2090     };
__anonede6c0371a02() 2091     infoPtr->menuCallback.onPaste = []() {
2092         callBackFlag = 2;
2093         return;
2094     };
2095 
2096     /**
2097     * @tc.steps: step3. call UpdateToolBar for call the other function.
2098     * @tc.expected: the isExtensionMenu_ value was successfully changed.
2099     */
2100     selectOverlayNode->UpdateToolBar(false);
2101     EXPECT_TRUE(selectOverlayNode->isExtensionMenu_);
2102     selectOverlayNode->UpdateToolBar(true);
2103     EXPECT_FALSE(selectOverlayNode->isExtensionMenu_);
2104 }
2105 
2106 /**
2107  * @tc.name: ExecuteOverlayStatus001
2108  * @tc.desc: Test ExecuteOverlayStatus function.
2109  * @tc.type: FUNC
2110  */
2111 HWTEST_F(SelectOverlayTestNg, ExecuteOverlayStatus001, TestSize.Level1)
2112 {
2113     /**
2114      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
2115      */
2116     SelectOverlayInfo selectInfo;
2117     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2118     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2119     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2120     ASSERT_NE(selectOverlayNode, nullptr);
2121 
2122     /**
2123      * @tc.steps: step2. Create invalid type and call ExecuteOverlayStatus function.
2124      */
2125 
2126     FrameNodeType type = (FrameNodeType) 4;
2127     selectOverlayNode->ExecuteOverlayStatus(type, FrameNodeTrigger::HIDDEN);
2128     ASSERT_NE(selectOverlayNode, nullptr);
2129 }
2130 
2131 /**
2132  * @tc.name: SetFrameNodeOpacity002
2133  * @tc.desc: Test SetFrameNodeOpacity function.
2134  * @tc.type: FUNC
2135  */
2136 HWTEST_F(SelectOverlayTestNg, SetFrameNodeOpacity002, TestSize.Level1)
2137 {
2138     /**
2139      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
2140      */
2141     SelectOverlayInfo selectInfo;
2142     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2143     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2144     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2145     ASSERT_NE(selectOverlayNode, nullptr);
2146 
2147     /**
2148      * @tc.steps: step2. Create invalid type and call SetFrameNodeOpacity function.
2149      */
2150 
2151     FrameNodeType type = (FrameNodeType) 4;
2152     selectOverlayNode->SetFrameNodeOpacity(type, 0.0);
2153     ASSERT_NE(selectOverlayNode, nullptr);
2154 }
2155 
2156 /**
2157  * @tc.name: SetFrameNodeVisibility002
2158  * @tc.desc: Test SetFrameNodeVisibility function.
2159  * @tc.type: FUNC
2160  */
2161 HWTEST_F(SelectOverlayTestNg, SetFrameNodeVisibility002, TestSize.Level1)
2162 {
2163     /**
2164      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
2165      */
2166     SelectOverlayInfo selectInfo;
2167     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2168     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2169     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2170     ASSERT_NE(selectOverlayNode, nullptr);
2171 
2172     /**
2173      * @tc.steps: step2. Create invalid type and call SetFrameNodeVisibility function.
2174      */
2175 
2176     FrameNodeType type = (FrameNodeType) 4;
2177     selectOverlayNode->SetFrameNodeVisibility(type, VisibleType::INVISIBLE);
2178     ASSERT_NE(selectOverlayNode, nullptr);
2179 }
2180 
2181 /**
2182  * @tc.name: SetFrameNodeStatus002
2183  * @tc.desc: Test SetFrameNodeStatus function.
2184  * @tc.type: FUNC
2185  */
2186 HWTEST_F(SelectOverlayTestNg, SetFrameNodeStatus002, TestSize.Level1)
2187 {
2188     /**
2189      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
2190      */
2191     SelectOverlayInfo selectInfo;
2192     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2193     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2194     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2195     ASSERT_NE(selectOverlayNode, nullptr);
2196 
2197     /**
2198      * @tc.steps: step2. Create invalid type and call SetFrameNodeStatus function.
2199      */
2200 
2201     FrameNodeType type = (FrameNodeType) 4;
2202     selectOverlayNode->SetFrameNodeStatus(type, FrameNodeStatus::VISIBLE);
2203     ASSERT_NE(selectOverlayNode, nullptr);
2204 }
2205 
2206 /**
2207  * @tc.name: SelectOverlayNodeTest003
2208  * @tc.desc: Test IsInSelectedOrSelectOverlayArea with menuOptions.
2209  * @tc.type: FUNC
2210  */
2211 HWTEST_F(SelectOverlayTestNg, SelectOverlayNodeTest003, TestSize.Level1)
2212 {
2213     /**
2214      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
2215      */
2216     SelectOverlayInfo selectInfo;
2217     selectInfo.singleLineHeight = NODE_ID;
2218     selectInfo.menuOptionItems = GetMenuOptionItems();
2219     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2220     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2221     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2222     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2223     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2224     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2225     ASSERT_NE(selectOverlayNode, nullptr);
2226 
2227     /**
2228      * @tc.steps: step2. Create pattern and initialize HandleRegion
2229      */
2230     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2231     ASSERT_NE(pattern, nullptr);
2232     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
2233     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
2234 
2235     /**
2236      * @tc.steps: step3. Construct Point and Call IsInSelectedOrSelectOverlayArea.
2237      * @tc.expected: return false
2238      */
__anonede6c0371b02() 2239     pattern->info_->menuInfo.menuBuilder = []() {
2240         return ;
2241     };
2242     frameNode->geometryNode_ = nullptr;
2243     selectOverlayNode->selectMenu_ = nullptr;
2244     selectOverlayNode->extensionMenu_ = nullptr;
2245     const NG::PointF point { 9.0f, 12.0f };
2246     auto result = selectOverlayNode->IsInSelectedOrSelectOverlayArea(point);
2247     EXPECT_FALSE(result);
2248 
2249     /**
2250      * @tc.steps: step4. Construct Point and Call IsInSelectedOrSelectOverlayArea.
2251      * @tc.expected: return true
2252      */
2253     const NG::PointF point2 { 12.0f, 12.0f };
2254     auto result2 = selectOverlayNode->IsInSelectedOrSelectOverlayArea(point2);
2255     EXPECT_TRUE(result2);
2256 }
2257 
2258 /**
2259  * @tc.name: DispatchGoneToVisibleState01
2260  * @tc.desc: Test DispatchGoneToVisibleState function.
2261  * @tc.type: FUNC
2262  */
2263 HWTEST_F(SelectOverlayTestNg, DispatchGoneToVisibleState001, TestSize.Level1)
2264 {
2265     /**
2266      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
2267      */
2268     SelectOverlayInfo selectInfo;
2269     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2270     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2271     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2272     ASSERT_NE(selectOverlayNode, nullptr);
2273 
2274     /**
2275      * @tc.steps: step2. Create invalid type and call DispatchGoneToVisibleState function.
2276      */
2277     FrameNodeType type = FrameNodeType::BACKBUTTON;
2278     FrameNodeTrigger trigger = (FrameNodeTrigger) 4;
2279     selectOverlayNode->DispatchGoneToVisibleState(type, trigger);
2280     ASSERT_NE(selectOverlayNode, nullptr);
2281 }
2282 
2283 /**
2284  * @tc.name: DispatchGoneState001
2285  * @tc.desc: Test DispatchGoneState function.
2286  * @tc.type: FUNC
2287  */
2288 HWTEST_F(SelectOverlayTestNg, DispatchGoneState001, TestSize.Level1)
2289 {
2290     /**
2291      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
2292      */
2293     SelectOverlayInfo selectInfo;
2294     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2295     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2296     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2297     ASSERT_NE(selectOverlayNode, nullptr);
2298 
2299     /**
2300      * @tc.steps: step2. Create invalid type and call DispatchGoneState function.
2301      */
2302     FrameNodeType type = FrameNodeType::BACKBUTTON;
2303     FrameNodeTrigger trigger = (FrameNodeTrigger) 4;
2304     selectOverlayNode->DispatchGoneState(type, trigger);
2305     ASSERT_NE(selectOverlayNode, nullptr);
2306 }
2307 
2308 /**
2309  * @tc.name: IsTextAreaSelectAll001
2310  * @tc.desc: Test IsTextAreaSelectAll in Select Overlay algorithm.
2311  * @tc.type: FUNC
2312  */
2313 HWTEST_F(SelectOverlayTestNg, IsTextAreaSelectAll001, TestSize.Level1)
2314 {
2315     /**
2316      * @tc.steps: step1. Create selectInfo
2317      */
2318     SelectOverlayInfo selectInfo;
2319     selectInfo.singleLineHeight = NODE_ID;
2320 
2321     /**
2322     * @tc.steps: step2. Get layoutWrapper and layoutAlgorithm.
2323     */
2324     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2325     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2326     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2327     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2328     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2329     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2330     ASSERT_NE(selectOverlayNode, nullptr);
2331     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2332     ASSERT_NE(pattern, nullptr);
2333     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2334     auto layoutWrapper =
2335         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2336     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2337     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
2338 
2339     /**
2340     * @tc.steps: step3. Test cases.
2341     */
2342     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
2343     for (int i = 0; i < 2; ++i) {
2344         infoPtr->firstHandle.isShow = i;
2345         for (int j = 0; j < 2; ++j) {
2346             infoPtr->secondHandle.isShow = j;
2347             EXPECT_FALSE(newNode->IsTextAreaSelectAll());
2348         }
2349     }
2350 
2351     infoPtr->menuInfo.menuOffset = {0, 0};
2352     for (int i = 0; i < 2; ++i) {
2353         infoPtr->firstHandle.isShow = i;
2354         for (int j = 0; j < 2; ++j) {
2355             infoPtr->secondHandle.isShow = j;
2356             EXPECT_EQ(newNode->IsTextAreaSelectAll(), i == 0 || j == 0);
2357         }
2358     }
2359 }
2360 
2361 /**
2362  * @tc.name: ComputeExtensionMenuPosition001
2363  * @tc.desc: Test ComputeExtensionMenuPosition in Select Overlay algorithm.
2364  * @tc.type: FUNC
2365  */
2366 HWTEST_F(SelectOverlayTestNg, ComputeExtensionMenuPosition001, TestSize.Level1)
2367 {
2368     /**
2369      * @tc.steps: step1. Create selectInfo
2370      */
2371     SelectOverlayInfo selectInfo;
2372     selectInfo.singleLineHeight = NODE_ID;
2373 
2374     /**
2375     * @tc.steps: step2. Get layoutWrapper and layoutAlgorithm.
2376     */
2377     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2378     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2379     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2380     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2381     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2382     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2383     ASSERT_NE(selectOverlayNode, nullptr);
2384     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2385     ASSERT_NE(pattern, nullptr);
2386     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2387     auto layoutWrapper =
2388         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2389     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2390     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
2391 
2392     /**
2393     * @tc.steps: step3. Test Case.
2394     */
2395     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
2396     newNode->ComputeSelectMenuPosition(AccessibilityManager::RawPtr(layoutWrapper));
2397 }
2398 
2399 /**
2400  * @tc.name: CheckInShowArea001
2401  * @tc.desc: Test CheckInShowArea in Select Overlay algorithm.
2402  * @tc.type: FUNC
2403  */
2404 HWTEST_F(SelectOverlayTestNg, CheckInShowArea001, TestSize.Level1)
2405 {
2406     /**
2407      * @tc.steps: step1. Create selectInfo
2408      */
2409     SelectOverlayInfo selectInfo;
2410     selectInfo.singleLineHeight = NODE_ID;
2411 
2412     /**
2413     * @tc.steps: step2. Get layoutWrapper and layoutAlgorithm.
2414     */
2415     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2416     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2417     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2418     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2419     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2420     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2421     ASSERT_NE(selectOverlayNode, nullptr);
2422     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2423     ASSERT_NE(pattern, nullptr);
2424     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2425     auto layoutWrapper =
2426         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2427     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2428     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
2429 
2430     /**
2431     * @tc.steps: step3. Test cases.
2432     */
2433     std::vector<RectF> handlePaintRect = {
2434         {1, 1, 1, 1}, {3, 3, 1, 1}
2435     };
2436     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
2437     SelectOverlayInfo selectInfo1;
2438     selectInfo1.useFullScreen = false;
2439     selectInfo1.isSingleHandle = false;
2440     selectInfo1.showArea = {1, 1, 1, 1};
2441 
2442     for (uint32_t first = 0; first < handlePaintRect.size(); ++first) {
2443         selectInfo1.firstHandle.paintRect = handlePaintRect[first];
2444         for (uint32_t second = 0; second < handlePaintRect.size(); ++second) {
2445             selectInfo1.secondHandle.paintRect = handlePaintRect[second];
2446             bool expectRes = (first == 0) && (second == 0);
2447             EXPECT_EQ(newNode->CheckInShowArea(selectInfo1), expectRes);
2448         }
2449     }
2450 }
2451 
2452 /**
2453  * @tc.name: ComputeSelectMenuPosition001
2454  * @tc.desc: Test ComputeSelectMenuPosition in Select Overlay algorithm.
2455  * @tc.type: FUNC
2456  */
2457 HWTEST_F(SelectOverlayTestNg, ComputeSelectMenuPosition001, TestSize.Level1)
2458 {
2459     /**
2460      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
2461      */
2462     SelectOverlayInfo selectInfo;
2463     selectInfo.singleLineHeight = NODE_ID;
2464     selectInfo.menuOptionItems = GetMenuOptionItems();
2465     selectInfo.menuInfo.menuIsShow = false;
2466 
2467     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2468     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2469     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2470     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2471     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2472     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2473     ASSERT_NE(selectOverlayNode, nullptr);
2474 
2475     /**
2476     * @tc.steps: step2. Create pattern and geometryNode.
2477     */
2478     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2479     ASSERT_NE(pattern, nullptr);
2480     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2481     geometryNode->SetFrameSize({ 300, 150 });
2482 
2483     /**
2484     * @tc.steps: step3. Get layoutWrapper and layoutAlgorithm.
2485     * @tc.expected: layoutWrapper and layoutAlgorithm are created successfully
2486     */
2487     auto layoutWrapper =
2488         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2489     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2490     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
2491     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
2492     layoutWrapper->SetLayoutAlgorithm(
2493         AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
2494 
2495     auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
2496     childLayoutConstraint.selfIdealSize = OptionalSizeF(FIRST_ITEM_SIZE);
2497 
2498     // create menu and extensionMenu
2499     auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0371c02() 2500         V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "Test", TYPE); });
2501     // add item to selectOverlayNode
2502     selectOverlayNode->AddChild(item);
2503     RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
2504 
2505     firstGeometryNode->Reset();
2506     firstGeometryNode->SetFrameSize({ 2, 1 });
2507 
2508     RefPtr<LayoutWrapperNode> firstLayoutWrapper =
2509         AceType::MakeRefPtr<LayoutWrapperNode>(item, firstGeometryNode, item->GetLayoutProperty());
2510     ASSERT_NE(firstLayoutWrapper, nullptr);
2511     auto itemPattern = item->GetPattern<MenuPattern>();
2512     ASSERT_NE(itemPattern, nullptr);
2513     firstLayoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(childLayoutConstraint);
2514     auto itemLayoutAlgorithm = itemPattern->CreateLayoutAlgorithm();
2515     ASSERT_NE(itemLayoutAlgorithm, nullptr);
2516 
2517     firstLayoutWrapper->SetLayoutAlgorithm(
2518         AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(itemLayoutAlgorithm));
2519     firstLayoutWrapper->GetLayoutProperty()->UpdateUserDefinedIdealSize(
2520         CalcSize(CalcLength(FIRST_ITEM_WIDTH), CalcLength(FIRST_ITEM_HEIGHT)));
2521     layoutWrapper->AppendChild(firstLayoutWrapper);
2522 
2523     /**
2524     * @tc.steps: step4. Test cases.
2525     */
2526     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
2527 
2528     infoPtr->firstHandle.paintRect = {
2529         1, 1, 1, 1
2530     };
2531     infoPtr->secondHandle.paintRect = {
2532         3, 3, 1, 1
2533     };
2534 
2535     auto ret1 = newNode->ComputeSelectMenuPosition(AccessibilityManager::RawPtr(layoutWrapper));
2536     OffsetF expectRet1(16.0, 2.0);
2537     bool equal1 = (ret1 == expectRet1);
2538     EXPECT_TRUE(equal1);
2539 
2540     infoPtr->firstHandle.isShow = false;
2541     infoPtr->menuInfo.menuOffset = {1, 1};
2542     infoPtr->secondHandle.isShow = false;
2543     infoPtr->isSingleHandle = true;
2544     auto ret2 = newNode->ComputeSelectMenuPosition(AccessibilityManager::RawPtr(layoutWrapper));
2545     OffsetF expectRet2(16.0, 1.0);
2546     bool equal2 = (ret2 == expectRet2);
2547     EXPECT_TRUE(equal2);
2548 }
2549 
2550 /**
2551  * @tc.name: NewMenuAvoidStrategy001
2552  * @tc.desc: Test NewMenuAvoidStrategy001 in Select Overlay algorithm.
2553  * @tc.type: FUNC
2554  */
2555 HWTEST_F(SelectOverlayTestNg, NewMenuAvoidStrategy001, TestSize.Level1)
2556 {
2557     /**
2558      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
2559      */
2560     SelectOverlayInfo selectInfo;
2561     selectInfo.singleLineHeight = NODE_ID;
2562     selectInfo.menuOptionItems = GetMenuOptionItems();
2563     selectInfo.menuInfo.menuIsShow = false;
2564     selectInfo.selectArea = { 100, 500, 200, 50 };
2565 
2566     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2567     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2568     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2569     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2570     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2571     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2572     ASSERT_NE(selectOverlayNode, nullptr);
2573 
2574     /**
2575     * @tc.steps: step2. Create pattern and geometryNode.
2576     */
2577     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2578     ASSERT_NE(pattern, nullptr);
2579     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2580 
2581     /**
2582     * @tc.steps: step3. Get layoutWrapper and layoutAlgorithm.
2583     * @tc.expected: layoutWrapper and layoutAlgorithm are created successfully
2584     */
2585     auto layoutWrapper =
2586         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2587     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2588     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
2589     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
2590 
2591     /**
2592     * @tc.steps: step4. Test cases.
2593     */
2594     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
2595 
2596     auto menuWidth = 200;
2597     auto menuHeight = 100;
2598     auto ret1 = newNode->NewMenuAvoidStrategy(AccessibilityManager::RawPtr(layoutWrapper), menuWidth, menuHeight);
2599     std::cout << ret1.ToString();
2600     OffsetF expectRet1(100, 398);
2601     bool equal1 = (ret1 == expectRet1);
2602     EXPECT_TRUE(equal1);
2603 
2604     infoPtr->firstHandle.isShow = false;
2605     infoPtr->secondHandle.isShow = false;
2606     auto ret2 = newNode->NewMenuAvoidStrategy(AccessibilityManager::RawPtr(layoutWrapper), menuWidth, menuHeight);
2607     OffsetF expectRet2(100, -100);
2608     bool equal2 = (ret2 == expectRet2);
2609     EXPECT_TRUE(equal2);
2610 
2611     infoPtr->firstHandle.isShow = false;
2612     infoPtr->secondHandle.isShow = true;
2613     auto ret3 = newNode->NewMenuAvoidStrategy(AccessibilityManager::RawPtr(layoutWrapper), menuWidth, menuHeight);
2614     OffsetF expectRet3(100, 0);
2615     bool equal3 = (ret3 == expectRet3);
2616     EXPECT_TRUE(equal3);
2617 }
2618 
2619 /**
2620  * @tc.name: NewMenuAvoidStrategy002
2621  * @tc.desc: Test NewMenuAvoidStrategy002 in Select Overlay algorithm.
2622  * @tc.type: FUNC
2623  */
2624 HWTEST_F(SelectOverlayTestNg, NewMenuAvoidStrategy002, TestSize.Level1)
2625 {
2626     /**
2627      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
2628      */
2629     SelectOverlayInfo selectInfo;
2630     selectInfo.singleLineHeight = NODE_ID;
2631     selectInfo.menuOptionItems = GetMenuOptionItems();
2632     selectInfo.menuInfo.menuIsShow = false;
2633     selectInfo.selectArea = { 100, 500, 200, 50 };
2634 
2635     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2636     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2637     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2638     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2639     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2640     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2641     ASSERT_NE(selectOverlayNode, nullptr);
2642 
2643     /**
2644     * @tc.steps: step2. Create pattern and geometryNode.
2645     */
2646     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2647     ASSERT_NE(pattern, nullptr);
2648     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2649 
2650     /**
2651     * @tc.steps: step3. Get layoutWrapper and layoutAlgorithm.
2652     * @tc.expected: layoutWrapper and layoutAlgorithm are created successfully
2653     */
2654     auto layoutWrapper =
2655         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2656     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2657     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
2658     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
2659 
2660     /**
2661     * @tc.steps: step4. set keyboardInset_ to button.
2662     */
2663     SafeAreaInsets::Inset insetBottom;
2664     insetBottom.start = RK356_HEIGHT - 1;
2665     insetBottom.end = RK356_HEIGHT;
2666     RefPtr<SafeAreaManager> safeAreamanager = AceType::MakeRefPtr<SafeAreaManager>();
2667     safeAreamanager->keyboardInset_ = SafeAreaInsets::Inset(insetBottom);
2668 
2669     auto pipeline = PipelineContext::GetCurrentContext();
2670     CHECK_NULL_VOID(pipeline);
2671     pipeline->safeAreaManager_ = safeAreamanager;
2672 
2673     /**
2674     * @tc.steps: step5. Test cases.
2675     */
2676     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
2677 
2678     auto menuWidth = 200;
2679     auto menuHeight = 100;
2680     infoPtr->firstHandle.isShow = false;
2681     infoPtr->secondHandle.isShow = false;
2682     auto ret = newNode->NewMenuAvoidStrategy(AccessibilityManager::RawPtr(layoutWrapper), menuWidth, menuHeight);
2683     OffsetF expectRet(100, 200);
2684     bool equal = (ret == expectRet);
2685     EXPECT_TRUE(equal);
2686 }
2687 
2688 /**
2689  * @tc.name: UpdateFirstAndSecondHandleInfo001
2690  * @tc.desc: Test SelectOverlayPattern UpdateFirstAndSecondHandleInfo.
2691  * @tc.type: FUNC
2692  */
2693 HWTEST_F(SelectOverlayTestNg, UpdateFirstAndSecondHandleInfo001, TestSize.Level1)
2694 {
2695     /**
2696      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
2697      */
2698     SelectOverlayInfo selectInfo;
2699     selectInfo.menuOptionItems = GetMenuOptionItems();
2700     selectInfo.singleLineHeight = NODE_ID;
2701 
2702     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2703     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2704     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2705     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2706     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2707     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2708     ASSERT_NE(selectOverlayNode, nullptr);
2709 
2710     /**
2711      * @tc.steps: step2. Create pattern.
2712      */
2713     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2714     ASSERT_NE(pattern, nullptr);
2715     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
2716 
2717     /**
2718      * @tc.steps: step3. Test cases.
2719      */
2720     SelectHandleInfo comInfoFirst;
2721     comInfoFirst.isShow = true;
2722     SelectHandleInfo comInfoSecond;
2723     comInfoSecond.isShow = false;
2724 
2725     pattern->info_->firstHandle.isShow = true;
2726     pattern->info_->secondHandle.isShow = true;
2727     pattern->UpdateFirstAndSecondHandleInfo(comInfoFirst, comInfoSecond);
2728     EXPECT_EQ(pattern->info_->firstHandle, comInfoFirst);
2729     EXPECT_EQ(pattern->info_->secondHandle, comInfoSecond);
2730 
2731     pattern->info_->firstHandle.isShow = true;
2732     pattern->info_->secondHandle.isShow = true;
2733     pattern->UpdateFirstAndSecondHandleInfo(comInfoSecond, comInfoFirst);
2734     EXPECT_EQ(pattern->info_->firstHandle, comInfoSecond);
2735     EXPECT_EQ(pattern->info_->secondHandle, comInfoFirst);
2736 
2737     pattern->info_->firstHandle.isShow = true;
2738     pattern->info_->secondHandle.isShow = true;
2739     pattern->UpdateFirstAndSecondHandleInfo(comInfoSecond, comInfoSecond);
2740     EXPECT_EQ(pattern->info_->firstHandle, comInfoSecond);
2741     EXPECT_EQ(pattern->info_->secondHandle, comInfoSecond);
2742 
2743     pattern->info_->firstHandle.isShow = true;
2744     pattern->info_->secondHandle.isShow = true;
2745     pattern->UpdateFirstAndSecondHandleInfo(comInfoFirst, comInfoFirst);
2746     EXPECT_EQ(pattern->info_->firstHandle, comInfoFirst);
2747     EXPECT_EQ(pattern->info_->firstHandle, comInfoFirst);
2748 }
2749 
2750 /**
2751  * @tc.name: BeforeCreateLayoutWrapper001
2752  * @tc.desc: Test SelectOverlayPattern BeforeCreateLayoutWrapper.
2753  * @tc.type: FUNC
2754  */
2755 HWTEST_F(SelectOverlayTestNg, BeforeCreateLayoutWrapper001, TestSize.Level1)
2756 {
2757     /**
2758      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
2759      */
2760     SelectOverlayInfo selectInfo;
2761     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2762     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2763     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2764     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2765     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2766     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2767     ASSERT_NE(selectOverlayNode, nullptr);
2768 
2769     /**
2770      * @tc.steps: step2. Create pattern
2771      */
2772     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2773     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2774     ASSERT_NE(pattern, nullptr);
2775     callBackFlag = 1;
2776     pattern->BeforeCreateLayoutWrapper();
2777     EXPECT_EQ(callBackFlag, 1);
__anonede6c0371d02() 2778     pattern->info_->menuInfo.menuBuilder = []() {
2779         callBackFlag = 2;
2780         return;
2781     };
2782     pattern->BeforeCreateLayoutWrapper();
2783     EXPECT_EQ(callBackFlag, 1);
2784 
2785     auto layoutWrapper =
2786         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2787     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2788     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
2789     layoutWrapper->SetLayoutAlgorithm(
2790         AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
2791 
2792     auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
2793     childLayoutConstraint.selfIdealSize = OptionalSizeF(FIRST_ITEM_SIZE);
2794 
2795     // create menu and extensionMenu
2796     auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0371e02() 2797         V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "Test", TYPE); });
2798     // add item to selectOverlayNode
2799     RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
2800     selectOverlayNode->AddChild(item);
2801     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
2802 
2803     pattern->BeforeCreateLayoutWrapper();
2804     EXPECT_EQ(callBackFlag, 1);
2805 }
2806 
2807 /**
2808  * @tc.name: AddMenuResponseRegion001
2809  * @tc.desc: Test SelectOverlayPattern AddMenuResponseRegion.
2810  * @tc.type: FUNC
2811  */
2812 HWTEST_F(SelectOverlayTestNg, AddMenuResponseRegion001, TestSize.Level1)
2813 {
2814     /**
2815      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
2816      */
2817     SelectOverlayInfo selectInfo;
2818     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2819     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2820     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2821     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2822     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2823     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2824     ASSERT_NE(selectOverlayNode, nullptr);
2825 
2826     /**
2827      * @tc.steps: step2. Create pattern
2828      */
2829     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2830     ASSERT_NE(pattern, nullptr);
2831     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2832 
2833     auto layoutWrapper =
2834         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2835     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2836     ASSERT_NE(selectOverlayLayoutAlgorithm, nullptr);
2837     layoutWrapper->SetLayoutAlgorithm(
2838         AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
2839 
2840     auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
2841     childLayoutConstraint.selfIdealSize = OptionalSizeF(FIRST_ITEM_SIZE);
2842 
2843     // create menu and extensionMenu
2844     auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0371f02() 2845         V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "Test", TYPE); });
2846     // add item to selectOverlayNode
2847     RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
2848     selectOverlayNode->AddChild(item);
2849 
2850     std::vector<DimensionRect> tmp;
2851     auto layoutProperty = pattern->CreateLayoutProperty();
2852     frameNode->SetLayoutProperty(layoutProperty);
2853     pattern->AddMenuResponseRegion(tmp);
2854     EXPECT_EQ(tmp.size(), 2);
2855 
2856     tmp.clear();
2857     auto layoutProps = pattern->GetLayoutProperty<LayoutProperty>();
2858     layoutProps->UpdateSafeAreaInsets(SafeAreaInsets());
2859     pattern->AddMenuResponseRegion(tmp);
2860     EXPECT_EQ(tmp.size(), 2);
2861     // if TextOverlayTheme is NULL, SelectOverlayNode::CreateToolBar() still continue, result in 2 children.
2862 }
2863 
2864 /**
2865  * @tc.name: GetDefaultLineWidth001
2866  * @tc.desc: Test SelectOverlayPattern GetDefaultLineWidth.
2867  * @tc.type: FUNC
2868  */
2869 HWTEST_F(SelectOverlayTestNg, GetDefaultLineWidth001, TestSize.Level1)
2870 {
2871     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2872     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2873     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
2874     Dimension dimension = SelectHandleInfo::GetDefaultLineWidth();
2875     EXPECT_EQ(dimension.Value(), 2);
2876 }
2877 
2878 /**
2879  * @tc.name: Measure001
2880  * @tc.desc: Test SelectOverlayLayoutAlgorithm Measure.
2881  * @tc.type: FUNC
2882  */
2883 HWTEST_F(SelectOverlayTestNg, Measure001, TestSize.Level1)
2884 {
2885     SelectOverlayInfo selectInfo;
2886     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2887     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2888     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2889     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2890     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2891     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2892     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2893     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
__anonede6c0372002() 2894     pattern->info_->menuInfo.menuBuilder = []() { return; };
2895     auto layoutWrapper =
2896         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2897     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2898     layoutWrapper->SetLayoutAlgorithm(
2899         AceType::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
2900     auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
2901     childLayoutConstraint.selfIdealSize = OptionalSizeF(FIRST_ITEM_SIZE);
2902     auto menu = layoutWrapper->GetOrCreateChildByIndex(0);
2903     auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0372102() 2904         V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "Test", TYPE); });
2905     RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
2906     selectOverlayNode->AddChild(item);
2907     firstGeometryNode->Reset();
2908     firstGeometryNode->SetFrameSize({ 2, 1 });
2909     RefPtr<LayoutWrapperNode> firstLayoutWrapper =
2910         AceType::MakeRefPtr<LayoutWrapperNode>(item, firstGeometryNode, item->GetLayoutProperty());
2911     auto itemPattern = item->GetPattern<MenuPattern>();
2912     firstLayoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(childLayoutConstraint);
2913     auto itemLayoutAlgorithm = itemPattern->CreateLayoutAlgorithm();
2914     firstLayoutWrapper->SetLayoutAlgorithm(
2915         AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(itemLayoutAlgorithm));
2916     firstLayoutWrapper->GetLayoutProperty()->UpdateUserDefinedIdealSize(
2917         CalcSize(CalcLength(FIRST_ITEM_WIDTH), CalcLength(FIRST_ITEM_HEIGHT)));
2918     layoutWrapper->AppendChild(firstLayoutWrapper);
2919     selectOverlayLayoutAlgorithm->Measure(AceType::RawPtr(layoutWrapper));
2920     EXPECT_EQ(layoutWrapper->GetChildByIndex(1), nullptr);
2921 }
2922 
2923 /**
2924  * @tc.name: Measure002
2925  * @tc.desc: Test SelectOverlayLayoutAlgorithm Measure.
2926  * @tc.type: FUNC
2927  */
2928 HWTEST_F(SelectOverlayTestNg, Measure002, TestSize.Level1)
2929 {
2930     SelectOverlayInfo selectInfo;
2931     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2932     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2933     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2934     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2935     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2936     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2937     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2938     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2939     pattern->info_->menuInfo.menuBuilder = nullptr;
2940     auto layoutWrapper =
2941         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2942     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2943     layoutWrapper->SetLayoutAlgorithm(
2944         AceType::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
2945     auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
2946     childLayoutConstraint.selfIdealSize = OptionalSizeF(FIRST_ITEM_SIZE);
2947     auto menu = layoutWrapper->GetOrCreateChildByIndex(0);
2948     auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0372202() 2949         V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "Test", TYPE); });
2950     RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
2951     selectOverlayNode->AddChild(item);
2952     auto layoutProperty = pattern->CreateLayoutProperty();
2953     selectOverlayLayoutAlgorithm->Measure(AceType::RawPtr(layoutWrapper));
2954     EXPECT_EQ(layoutWrapper->GetChildByIndex(1), nullptr);
2955 }
2956 
2957 /**
2958  * @tc.name: CalculateCustomMenuByMouseOffset
2959  * @tc.desc: Test SelectOverlayLayoutAlgorithm CalculateCustomMenuByMouseOffset.
2960  * @tc.type: FUNC
2961  */
2962 HWTEST_F(SelectOverlayTestNg, CalculateCustomMenuByMouseOffset, TestSize.Level1)
2963 {
2964     SelectOverlayInfo selectInfo;
2965     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2966     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2967     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2968     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
2969     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
2970     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
2971     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
2972     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2973     auto layoutWrapper =
2974         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
2975     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
2976     layoutWrapper->SetLayoutAlgorithm(
2977         AceType::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
2978     SelectMenuInfo infoMenu;
2979     OffsetF testCase(4, 5);
2980     infoMenu.menuOffset = testCase;
2981     pattern->UpdateSelectMenuInfo(infoMenu);
2982     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
2983     newNode->CalculateCustomMenuByMouseOffset(AceType::RawPtr(layoutWrapper));
2984     EXPECT_EQ(pattern->info_->menuInfo.menuOffset, testCase);
2985 }
2986 
2987 /**
2988  * @tc.name: CalculateCustomMenuLayoutConstraint
2989  * @tc.desc: Test SelectOverlayLayoutAlgorithm CalculateCustomMenuLayoutConstraint.
2990  * @tc.type: FUNC
2991  */
2992 HWTEST_F(SelectOverlayTestNg, CalculateCustomMenuLayoutConstraint, TestSize.Level1)
2993 {
2994     SelectOverlayInfo selectInfo;
2995     SelectHandleInfo firstHandle;
2996     firstHandle.paintRect = FIRST_HANDLE_REGION;
2997     SelectHandleInfo secondHandle;
2998     secondHandle.paintRect = SECOND_HANDLE_REGION2;
2999     selectInfo.firstHandle = firstHandle;
3000     selectInfo.secondHandle = secondHandle;
3001     selectInfo.selectArea = { 100, 500, 200, 50 };
3002 
3003     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3004     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3005     auto textOverlayTheme = AceType::MakeRefPtr<TextOverlayTheme>();
3006     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(textOverlayTheme));
3007     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3008     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3009     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3010     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3011     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
__anonede6c0372302() 3012     pattern->info_->menuInfo.menuBuilder = []() { return; };
3013     auto layoutWrapper =
3014         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
3015     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
3016     layoutWrapper->SetLayoutAlgorithm(AceType::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
3017     auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
3018     childLayoutConstraint.maxSize = SizeF(FIRST_ITEM_SIZE);
3019 
3020     auto menu = layoutWrapper->GetOrCreateChildByIndex(0);
3021     auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0372402() 3022         V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "test", TYPE); });
3023     selectOverlayNode->AddChild(item);
3024 
3025     layoutWrapper->GetGeometryNode()->GetFrameOffset() = OFFSET_ITEM1;
3026     infoPtr->isNewAvoid = false;
3027     infoPtr->isUsingMouse = false;
3028     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
3029     newNode->CalculateCustomMenuLayoutConstraint(AceType::RawPtr(layoutWrapper), childLayoutConstraint);
3030     EXPECT_EQ(childLayoutConstraint.selfIdealSize.Height(), 45);
3031 }
3032 
3033 /**
3034  * @tc.name: CalculateCustomMenuByMouseOffset002
3035  * @tc.desc: Test SelectOverlayLayoutAlgorithm CalculateCustomMenuByMouseOffset.
3036  * @tc.type: FUNC
3037  */
3038 HWTEST_F(SelectOverlayTestNg, CalculateCustomMenuByMouseOffset002, TestSize.Level1)
3039 {
3040     SelectOverlayInfo selectInfo;
3041     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3042     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3043     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3044     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3045     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3046     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3047     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3048     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
3049     auto layoutWrapper =
3050         AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
3051     auto selectOverlayLayoutAlgorithm = pattern->CreateLayoutAlgorithm();
3052     layoutWrapper->SetLayoutAlgorithm(AceType::MakeRefPtr<LayoutAlgorithmWrapper>(selectOverlayLayoutAlgorithm));
3053     auto childLayoutConstraint = layoutWrapper->GetLayoutProperty()->CreateChildConstraint();
3054     childLayoutConstraint.selfIdealSize = OptionalSizeF(FIRST_ITEM_SIZE);
3055 
3056     auto item = FrameNode::GetOrCreateFrameNode(
__anonede6c0372502() 3057         V2::MENU_ETS_TAG, -1, []() { return AceType::MakeRefPtr<MenuPattern>(1, "Test", TYPE); });
3058     selectOverlayNode->AddChild(item);
3059     RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3060     firstGeometryNode->Reset();
3061     firstGeometryNode->SetFrameSize({ 2, 1 });
3062     RefPtr<LayoutWrapperNode> firstLayoutWrapper =
3063         AceType::MakeRefPtr<LayoutWrapperNode>(item, firstGeometryNode, item->GetLayoutProperty());
3064     ASSERT_NE(firstLayoutWrapper, nullptr);
3065     auto itemPattern = item->GetPattern<MenuPattern>();
3066     ASSERT_NE(itemPattern, nullptr);
3067     firstLayoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(childLayoutConstraint);
3068     auto itemLayoutAlgorithm = itemPattern->CreateLayoutAlgorithm();
3069     ASSERT_NE(itemLayoutAlgorithm, nullptr);
3070     firstLayoutWrapper->SetLayoutAlgorithm(
3071         AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(itemLayoutAlgorithm));
3072     firstLayoutWrapper->GetLayoutProperty()->UpdateUserDefinedIdealSize(
3073         CalcSize(CalcLength(FIRST_ITEM_WIDTH), CalcLength(FIRST_ITEM_HEIGHT)));
3074     layoutWrapper->AppendChild(firstLayoutWrapper);
3075 
3076     SelectMenuInfo infoMenu;
3077     OffsetF testCase(4, 5);
3078     infoMenu.menuOffset = testCase;
3079     pattern->UpdateSelectMenuInfo(infoMenu);
3080     auto newNode = AceType::DynamicCast<SelectOverlayLayoutAlgorithm>(selectOverlayLayoutAlgorithm);
3081     newNode->CalculateCustomMenuByMouseOffset(AceType::RawPtr(layoutWrapper));
3082     EXPECT_EQ(pattern->info_->menuInfo.menuOffset->GetX(), 4.0f);
3083 }
3084 
3085 /**
3086  * @tc.name: StartHiddenHandleTask002
3087  * @tc.desc: Test SelectOverlayPattern StartHiddenHandleTask.
3088  * @tc.type: FUNC
3089  */
3090 HWTEST_F(SelectOverlayTestNg, StartHiddenHandleTask002, TestSize.Level1)
3091 {
3092     SelectOverlayInfo selectInfo;
3093     selectInfo.menuOptionItems = GetMenuOptionItems();
3094     selectInfo.singleLineHeight = NODE_ID;
3095     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3096     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3097     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3098     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3099     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3100     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3101     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3102     bool isDelay = false;
3103     RectF area;
3104     area = RectF(1, 1, 1, 1);
3105     pattern->UpdateShowArea(area);
3106     pattern->StartHiddenHandleTask(isDelay);
3107     EXPECT_NE(pattern->GetSelectOverlayInfo(), nullptr);
3108 }
3109 
3110 /**
3111  * @tc.name: SetSelectRegionVisible001
3112  * @tc.desc: Test SelectOverlayPattern SetSelectRegionVisible.
3113  * @tc.type: FUNC
3114  */
3115 HWTEST_F(SelectOverlayTestNg, SetSelectRegionVisible001, TestSize.Level1)
3116 {
3117     SelectOverlayInfo selectInfo;
3118     selectInfo.menuOptionItems = GetMenuOptionItems();
3119     selectInfo.singleLineHeight = NODE_ID;
3120     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3121     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3122     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3123     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3124     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3125     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3126     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3127     bool isSelectRegionVisible = true;
3128     pattern->SetSelectRegionVisible(isSelectRegionVisible);
3129     EXPECT_EQ(pattern->info_->isSelectRegionVisible, true);
3130 }
3131 
3132 /**
3133  * @tc.name: SetSelectRegionVisible002
3134  * @tc.desc: Test SelectOverlayPattern SetSelectRegionVisible.
3135  * @tc.type: FUNC
3136  */
3137 HWTEST_F(SelectOverlayTestNg, SetSelectRegionVisible002, TestSize.Level1)
3138 {
3139     SelectOverlayInfo selectInfo;
3140     selectInfo.menuOptionItems = GetMenuOptionItems();
3141     selectInfo.singleLineHeight = NODE_ID;
3142     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3143     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3144     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3145     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3146     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3147     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3148     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3149     bool isSelectRegionVisible = false;
3150     pattern->SetSelectRegionVisible(isSelectRegionVisible);
3151     EXPECT_EQ(pattern->info_->isSelectRegionVisible, false);
3152 }
3153 
3154 /**
3155  * @tc.name: UpdateSelectMenuInfo002
3156  * @tc.desc: Test SelectOverlayPattern UpdateSelectMenuInfo.
3157  * @tc.type: FUNC
3158  */
3159 HWTEST_F(SelectOverlayTestNg, UpdateSelectMenuInfo002, TestSize.Level1)
3160 {
3161     SelectOverlayInfo selectInfo;
3162     selectInfo.menuOptionItems = GetMenuOptionItems();
3163     selectInfo.singleLineHeight = NODE_ID;
3164     selectInfo.menuInfo.menuDisable = false;
3165     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3166     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3167     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3168     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3169     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3170     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3171     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3172     ASSERT_NE(pattern, nullptr);
3173     SelectMenuInfo infoMenu;
3174     OffsetF testCase(0, 0);
3175     infoMenu.menuOffset = testCase;
3176     pattern->UpdateSelectMenuInfo(infoMenu);
3177     EXPECT_EQ(pattern->info_->menuInfo.menuOffset, testCase);
3178 }
3179 
3180 /**
3181  * @tc.name: CreateToolBar001
3182  * @tc.desc: Test SelectOverlayNode CreateToolBar001.
3183  * @tc.type: FUNC
3184  */
3185 HWTEST_F(SelectOverlayTestNg, CreateToolBar001, TestSize.Level1)
3186 {
3187     SelectOverlayInfo selectInfo;
3188     selectInfo.menuInfo.menuIsShow = true;
__anonede6c0372602() 3189     selectInfo.menuInfo.menuBuilder = []() { return; };
__anonede6c0372702() 3190     selectInfo.menuCallback.onAppear = []() { return; };
__anonede6c0372802() 3191     selectInfo.menuCallback.onDisappear = []() { return; };
3192     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3193     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3194     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3195     selectOverlayNode->CreateToolBar();
3196     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
3197 }
3198 
3199 /**
3200  * @tc.name: CreateToolBar002
3201  * @tc.desc: Test SelectOverlayNode CreateToolBar002.
3202  * @tc.type: FUNC
3203  */
3204 HWTEST_F(SelectOverlayTestNg, CreateToolBar002, TestSize.Level1)
3205 {
3206     SelectOverlayInfo selectInfo;
3207     selectInfo.menuInfo.menuIsShow = false;
__anonede6c0372902() 3208     selectInfo.menuInfo.menuBuilder = []() { return; };
__anonede6c0372a02() 3209     selectInfo.menuCallback.onAppear = []() { return; };
__anonede6c0372b02() 3210     selectInfo.menuCallback.onDisappear = []() { return; };
3211     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3212     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3213     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3214     selectOverlayNode->CreateToolBar();
3215     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
3216 }
3217 
3218 /**
3219  * @tc.name: AddSystemDefaultOptions001
3220  * @tc.desc: Test SelectOverlayNode AddSystemDefaultOptions.
3221  * @tc.type: FUNC
3222  */
3223 HWTEST_F(SelectOverlayTestNg, AddSystemDefaultOptions001, TestSize.Level1)
3224 {
3225     SelectOverlayInfo selectInfo;
3226     selectInfo.menuInfo.showCut = true;
3227     selectInfo.menuInfo.showCopy = true;
3228     selectInfo.menuInfo.showPaste = true;
3229     selectInfo.menuInfo.showCopyAll = true;
3230     selectInfo.menuInfo.showCameraInput = true;
3231     float maxWidth = 2.0f;
3232     float allocatedSize = 3.0f;
3233     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3234     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3235     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3236     bool result = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3237     EXPECT_TRUE(result);
3238 }
3239 
3240 /**
3241  * @tc.name: AddSystemDefaultOptions002
3242  * @tc.desc: Test SelectOverlayNode AddSystemDefaultOptions.
3243  * @tc.type: FUNC
3244  */
3245 HWTEST_F(SelectOverlayTestNg, AddSystemDefaultOptions002, TestSize.Level1)
3246 {
3247     SelectOverlayInfo selectInfo;
3248     selectInfo.menuInfo.showCut = true;
3249     selectInfo.menuInfo.showCopy = false;
3250     selectInfo.menuInfo.showPaste = true;
3251     selectInfo.menuInfo.showCopyAll = true;
3252     selectInfo.menuInfo.showCameraInput = true;
3253     float maxWidth = 2.0f;
3254     float allocatedSize = 3.0f;
3255     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3256     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3257     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3258     bool result = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3259     EXPECT_TRUE(result);
3260 }
3261 
3262 /**
3263  * @tc.name: AddSystemDefaultOptions003
3264  * @tc.desc: Test SelectOverlayNode AddSystemDefaultOptions.
3265  * @tc.type: FUNC
3266  */
3267 HWTEST_F(SelectOverlayTestNg, AddSystemDefaultOptions003, TestSize.Level1)
3268 {
3269     SelectOverlayInfo selectInfo;
3270     selectInfo.menuInfo.showCut = true;
3271     selectInfo.menuInfo.showCopy = false;
3272     selectInfo.menuInfo.showPaste = false;
3273     selectInfo.menuInfo.showCopyAll = true;
3274     selectInfo.menuInfo.showCameraInput = true;
3275     float maxWidth = 2.0f;
3276     float allocatedSize = 3.0f;
3277     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3278     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3279     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3280     bool result = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3281     EXPECT_TRUE(result);
3282 }
3283 
3284 /**
3285  * @tc.name: AddSystemDefaultOptions004
3286  * @tc.desc: Test SelectOverlayNode AddSystemDefaultOptions.
3287  * @tc.type: FUNC
3288  */
3289 HWTEST_F(SelectOverlayTestNg, AddSystemDefaultOptions004, TestSize.Level1)
3290 {
3291     SelectOverlayInfo selectInfo;
3292     selectInfo.menuInfo.showCut = true;
3293     selectInfo.menuInfo.showCopy = false;
3294     selectInfo.menuInfo.showPaste = false;
3295     selectInfo.menuInfo.showCopyAll = false;
3296     selectInfo.menuInfo.showCameraInput = true;
3297     float maxWidth = 2.0f;
3298     float allocatedSize = 3.0f;
3299     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3300     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3301     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3302     bool result = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3303     EXPECT_TRUE(result);
3304 }
3305 
3306 /**
3307  * @tc.name: AddSystemDefaultOptions005
3308  * @tc.desc: Test SelectOverlayNode AddSystemDefaultOptions.
3309  * @tc.type: FUNC
3310  */
3311 HWTEST_F(SelectOverlayTestNg, AddSystemDefaultOptions005, TestSize.Level1)
3312 {
3313     SelectOverlayInfo selectInfo;
3314     selectInfo.menuInfo.showCut = true;
3315     selectInfo.menuInfo.showCopy = false;
3316     selectInfo.menuInfo.showPaste = false;
3317     selectInfo.menuInfo.showCopyAll = false;
3318     selectInfo.menuInfo.showCameraInput = false;
3319     float maxWidth = 2.0f;
3320     float allocatedSize = 3.0f;
3321     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3322     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3323     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3324     bool result = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3325     EXPECT_TRUE(result);
3326 }
3327 
3328 /**
3329  * @tc.name: AddSystemDefaultOptions006
3330  * @tc.desc: Test AddSystemDefaultOptions different parameter .
3331  * @tc.type: FUNC
3332  */
3333 HWTEST_F(SelectOverlayTestNg, AddSystemDefaultOptions006, TestSize.Level1)
3334 {
3335     /**
3336      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
3337     */
3338     SelectOverlayInfo selectInfo;
3339     selectInfo.menuInfo.showCut = true;
3340     selectInfo.menuInfo.showCopy = false;
3341     selectInfo.menuInfo.showPaste = false;
3342     selectInfo.menuInfo.showCopyAll = false;
3343     selectInfo.menuInfo.showCameraInput = false;
3344     float maxWidth = 3.0f;
3345     float allocatedSize = 2.0f;
3346     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3347     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3348     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3349     auto pipeline = PipelineContext::GetCurrentContext();
3350     CHECK_NULL_VOID(pipeline);
3351     /**
3352      * @tc.steps: step2. call AddSystemDefaultOptions.
3353      * @tc.expected: the value was successfully changed.
3354      */
3355     pipeline->SetFontScale(1.85f);
3356     bool result = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3357     EXPECT_FALSE(result);
3358 }
3359 
3360 /**
3361  * @tc.name: BuildButton001
3362  * @tc.desc: Test BuildButton different parameter .
3363  * @tc.type: FUNC
3364  */
3365 HWTEST_F(SelectOverlayTestNg, BuildButton001, TestSize.Level1)
3366 {
3367     /**
3368      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
3369     */
3370     SelectOverlayInfo selectInfo;
3371     selectInfo.menuInfo.showCut = true;
3372     selectInfo.menuInfo.showCopy = false;
3373     selectInfo.menuInfo.showPaste = false;
3374     selectInfo.menuInfo.showCopyAll = false;
3375     selectInfo.menuInfo.showCameraInput = false;
3376     float maxWidth = 3.0f;
3377     float allocatedSize = 2.0f;
3378     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
__anonede6c0372c02() 3379     infoPtr->menuCallback.onCut = []() {
3380         callBackFlag = 1;
3381         return ;
3382     };
3383     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3384     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3385     EXPECT_NE(selectOverlayNode->selectMenuInner_, nullptr);
3386 
3387     /**
3388      * @tc.steps: step2. call BuildButton.
3389      */
3390     bool result = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3391     EXPECT_FALSE(result);
3392     auto button = AceType::DynamicCast<FrameNode>(selectOverlayNode->selectMenuInner_->GetLastChild());
3393     EXPECT_NE(button, nullptr);
3394     auto gestureEventHubPtr = button->GetOrCreateGestureEventHub();
3395     EXPECT_NE(gestureEventHubPtr, nullptr);
3396     if (gestureEventHubPtr->clickEventActuator_) {
3397         auto playClickCallback = gestureEventHubPtr->clickEventActuator_->userCallback_->callback_;
3398         GestureEvent gestureEvent = GestureEvent();
3399         playClickCallback(gestureEvent);
3400     }
3401 
3402     if (gestureEventHubPtr->userParallelClickEventActuator_) {
3403         auto playClickCallback = gestureEventHubPtr->userParallelClickEventActuator_->userCallback_->callback_;
3404         GestureEvent gestureEvent = GestureEvent();
3405         playClickCallback(gestureEvent);
3406     }
3407     EXPECT_NE(selectOverlayNode->isShowInDefaultMenu_[0], false);
3408 }
3409 
3410 /**
3411  * @tc.name: CreateSelectOverlayNode001
3412  * @tc.desc: Test CreateSelectOverlayNode.
3413  * @tc.type: FUNC
3414  */
3415 HWTEST_F(SelectOverlayTestNg, CreateSelectOverlayNode001, TestSize.Level1)
3416 {
3417     /**
3418      * @tc.steps: step1. Create selectOverlayNode, pattern, canvas, context
3419      * and initialize properties.
3420     */
3421     SelectOverlayInfo selectInfo;
3422     selectInfo.menuInfo.menuDisable = true;
3423     selectInfo.menuInfo.showCut = false;
3424     selectInfo.menuInfo.showPaste = false;
3425     auto menuOptionItems = GetMenuOptionItems();
3426     selectInfo.menuOptionItems = menuOptionItems;
3427     selectInfo.singleLineHeight = NODE_ID;
3428     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3429     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3430     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3431     ASSERT_NE(selectOverlayNode, nullptr);
3432     selectOverlayNode->CreateToolBar();
3433     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3434     ASSERT_NE(pattern, nullptr);
3435     pattern->CreateNodePaintMethod();
3436     /**
3437      * @tc.steps: step2. set param and call function.
3438      */
3439     selectOverlayNode->DispatchVisibleToGoneState(FrameNodeType::SELECTMENU, FrameNodeTrigger::SHOW);
3440     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
3441     /**
3442      * @tc.steps: step2. set param and call function.
3443      */
3444     selectOverlayNode->DispatchGoneToVisibleState(FrameNodeType::SELECTMENU, FrameNodeTrigger::HIDE);
3445     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
3446 }
3447 
3448 /**
3449  * @tc.name: DispatchVisibleToGoneState001
3450  * @tc.desc: Test DispatchVisibleToGoneState.
3451  * @tc.type: FUNC
3452  */
3453 HWTEST_F(SelectOverlayTestNg, DispatchVisibleToGoneState001, TestSize.Level1)
3454 {
3455     /**
3456      * @tc.steps: step1. Create selectOverlayNode, pattern, canvas, context
3457      * and initialize properties.
3458     */
3459     SelectOverlayInfo selectInfo;
3460     selectInfo.menuInfo.menuDisable = true;
3461     selectInfo.menuInfo.showCut = false;
3462     selectInfo.menuInfo.showPaste = false;
3463     auto menuOptionItems = GetMenuOptionItems();
3464     selectInfo.menuOptionItems = menuOptionItems;
3465     selectInfo.singleLineHeight = NODE_ID;
3466     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3467     infoPtr->isUsingMouse = false;
3468     infoPtr->isUseOverlayNG = true;
3469     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3470     EXPECT_NE(frameNode, nullptr);
3471 }
3472 
3473 /**
3474  * @tc.name: UpdateToolBar003
3475  * @tc.desc: Test SelectOverlayNode UpdateToolBar.
3476  * @tc.type: FUNC
3477  */
3478 HWTEST_F(SelectOverlayTestNg, UpdateToolBar003, TestSize.Level1)
3479 {
3480     SelectOverlayInfo selectInfo;
3481     auto menuOptionItems = GetMenuOptionItems();
3482     selectInfo.menuOptionItems = menuOptionItems;
3483     selectInfo.menuInfo.showCut = true;
3484     selectInfo.menuInfo.showCopy = true;
3485     selectInfo.menuInfo.menuDisable = true;
3486     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3487     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3488     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3489     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 1);
3490     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3491     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3492     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
3493     selectOverlayNode->CreateToolBar();
3494     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3495     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0372d02() 3496         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
3497     selectOverlayNode->selectMenuStatus_ = FrameNodeStatus::VISIBLETOGONE;
3498     selectOverlayNode->extensionMenuStatus_ = FrameNodeStatus::GONETOVISIBLE;
3499     selectOverlayNode->backButtonStatus_ = FrameNodeStatus::GONETOVISIBLE;
3500     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3501     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
__anonede6c0372e02() 3502     infoPtr->menuCallback.onCut = []() { return; };
__anonede6c0372f02() 3503     infoPtr->menuCallback.onPaste = []() { return; };
__anonede6c0373002() 3504     infoPtr->menuInfo.menuBuilder = []() { return; };
3505     selectOverlayNode->backButton_ = nullptr;
3506     selectOverlayNode->UpdateToolBar(false);
3507     selectOverlayNode->UpdateToolBar(true);
3508     EXPECT_FALSE(selectOverlayNode->isExtensionMenu_);
3509 }
3510 
3511 /**
3512  * @tc.name: AddExtensionMenuOptions
3513  * @tc.desc: Test SelectOverlayNode AddExtensionMenuOptions.
3514  * @tc.type: FUNC
3515  */
3516 HWTEST_F(SelectOverlayTestNg, AddExtensionMenuOptions, TestSize.Level1)
3517 {
3518     SelectOverlayInfo selectInfo;
3519     auto menuOptionItems = GetMenuOptionItems();
3520     selectInfo.menuOptionItems = menuOptionItems;
3521     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3522     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3523     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3524     for (int i = 0; i < 7; i++) {
3525         selectOverlayNode->isShowInDefaultMenu_[i] = false;
3526     }
3527     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
3528     selectOverlayNode->AddExtensionMenuOptions(infoPtr, -1);
3529     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
3530 }
3531 
3532 /**
3533  * @tc.name: UpdateSelectMenuInfo003
3534  * @tc.desc: Test SelectOverlayPattern UpdateSelectMenuInfo.
3535  * @tc.type: FUNC
3536  */
3537 HWTEST_F(SelectOverlayTestNg, UpdateSelectMenuInfo003, TestSize.Level1)
3538 {
3539     SelectOverlayInfo selectInfo;
3540     selectInfo.menuOptionItems = GetMenuOptionItems();
3541     selectInfo.singleLineHeight = NODE_ID;
3542     selectInfo.menuInfo.menuDisable = false;
3543     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3544     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3545     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3546     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3547     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3548     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3549     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
__anonede6c0373102(SelectMenuInfo& infoMenu) 3550     auto updateAction = [](SelectMenuInfo& infoMenu) {
3551         return;
3552     };
3553     pattern->UpdateSelectMenuInfo(updateAction);
3554     std::function<void(SelectMenuInfo& infoMenu)> updateAction1 = nullptr;
3555     pattern->UpdateSelectMenuInfo(updateAction1);
3556     EXPECT_FALSE(selectInfo.menuInfo.menuDisable);
3557 }
3558 
3559 /**
3560  * @tc.name: CreateCustomSelectOverlay
3561  * @tc.desc: Test SelectOverlayNode CreateCustomSelectOverlay.
3562  * @tc.type: FUNC
3563  */
3564 HWTEST_F(SelectOverlayTestNg, CreateCustomSelectOverlay, TestSize.Level1)
3565 {
3566     SelectOverlayInfo selectInfo;
3567     selectInfo.menuInfo.menuIsShow = true;
3568     selectInfo.menuOptionItems = GetMenuOptionItems();
3569     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
__anonede6c0373202() 3570     infoPtr->menuInfo.menuBuilder = []() {
3571         return ;
3572     };
3573     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3574     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3575     selectOverlayNode->CreateCustomSelectOverlay(infoPtr);
3576     selectInfo.menuInfo.menuIsShow = false;
3577     selectOverlayNode->CreateCustomSelectOverlay(infoPtr);
3578     EXPECT_NE(selectOverlayNode->selectMenuStatus_, FrameNodeStatus::GONE);
3579 }
3580 
3581 /**
3582  * @tc.name: SelectOverlayModifier001
3583  * @tc.desc: Test selectOverlay modifier function.
3584  * @tc.type: FUNC
3585  */
3586 HWTEST_F(SelectOverlayTestNg, SelectOverlayModifier001, TestSize.Level1)
3587 {
3588     /**
3589      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
3590      */
3591     SelectOverlayInfo selectInfo;
3592     selectInfo.menuInfo.menuDisable = true;
3593     selectInfo.menuInfo.showCut = false;
3594     selectInfo.menuInfo.showPaste = false;
3595     auto menuOptionItems = GetMenuOptionItems();
3596     selectInfo.menuOptionItems = menuOptionItems;
3597     selectInfo.singleLineHeight = NODE_ID;
3598     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3599     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3600     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3601     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3602     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3603     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3604     EXPECT_NE(selectOverlayNode, nullptr);
3605     selectOverlayNode->CreateToolBar();
3606     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
3607     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0373302() 3608         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
3609     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
3610     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
3611     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
3612     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3613     EXPECT_NE(pattern, nullptr);
3614     RefPtr<NodePaintMethod> paintMethod = pattern->CreateNodePaintMethod();
3615     EXPECT_NE(paintMethod, nullptr);
3616     paintMethod = pattern->CreateNodePaintMethod();
3617     EXPECT_NE(paintMethod, nullptr);
3618     auto selectOverlayPaintMethod = AceType::DynamicCast<SelectOverlayPaintMethod>(paintMethod);
3619     EXPECT_NE(selectOverlayPaintMethod, nullptr);
3620     auto contentModifier = pattern->selectOverlayContentModifier_;
3621     EXPECT_NE(contentModifier, nullptr);
3622     auto selectOverlayModifier = pattern->selectOverlayModifier_;
3623     ASSERT_NE(selectOverlayModifier, nullptr);
3624 
3625     /**
3626      * @tc.steps: step2. Test selectOverlay modifier SelectOverlayModifier function.
3627      */
3628     selectOverlayModifier->SetDefaultCircleAndLineEndOffset();
3629     Dimension radius = 2.0_vp;
3630     selectOverlayModifier->pointRadius_ =
3631         AceType::MakeRefPtr<AnimatablePropertyFloat>(Dimension(1.75_vp).ConvertToPx());
3632     selectOverlayModifier->SetOtherPointRadius(radius);
3633     EXPECT_EQ(radius, 2.0_vp);
3634 }
3635 
3636 /**
3637  * @tc.name: IsInSelectedOrSelectOverlayArea003
3638  * @tc.desc: Test IsInSelectedOrSelectOverlayArea without menuOptions.
3639  * @tc.type: FUNC
3640  */
3641 HWTEST_F(SelectOverlayTestNg, IsInSelectedOrSelectOverlayArea003, TestSize.Level1)
3642 {
3643     /**
3644      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
3645      */
3646     SelectOverlayInfo selectInfo;
3647     selectInfo.singleLineHeight = NODE_ID;
3648     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3649     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3650     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3651     ASSERT_NE(selectOverlayNode, nullptr);
3652     /**
3653      * @tc.steps: step2. Create pattern and initialize HandleRegion
3654      */
3655     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3656     ASSERT_NE(pattern, nullptr);
3657     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
3658     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
3659     /**
3660      * @tc.steps: step3. Construct Point and Call IsInSelectedOrSelectOverlayArea.
3661      * @tc.expected: return false
3662      */
3663     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0373402() 3664         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
3665     const NG::PointF point { 9.0f, 12.0f };
3666     auto result = selectOverlayNode->IsInSelectedOrSelectOverlayArea(point);
3667     EXPECT_FALSE(result);
3668 }
3669 
3670 /**
3671  * @tc.name: IsInSelectedOrSelectOverlayArea004
3672  * @tc.desc: Test IsInSelectedOrSelectOverlayArea without patternChildren is not empty.
3673  * @tc.type: FUNC
3674  */
3675 HWTEST_F(SelectOverlayTestNg, IsInSelectedOrSelectOverlayArea004, TestSize.Level1)
3676 {
3677     /**
3678      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
3679      */
3680     SelectOverlayInfo selectInfo;
3681     selectInfo.singleLineHeight = NODE_ID;
3682     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3683     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3684     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3685     ASSERT_NE(selectOverlayNode, nullptr);
3686     /**
3687      * @tc.steps: step2. Create pattern and initialize HandleRegion
3688      */
3689     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3690     ASSERT_NE(pattern, nullptr);
3691     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
3692     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
3693 
3694     /**
3695      * @tc.steps: step3. Construct Point and Call IsInSelectedOrSelectOverlayArea.
3696      * @tc.expected: return false
3697      */
3698     const NG::PointF point { 9.0f, 12.0f };
3699     auto result = selectOverlayNode->IsInSelectedOrSelectOverlayArea(point);
3700     EXPECT_FALSE(result);
3701 }
3702 
3703 /**
3704  * @tc.name: UpdateMenuInner002
3705  * @tc.desc: Test UpdateMenuInner paddingWidth
3706  * @tc.type: FUNC
3707  */
3708 HWTEST_F(SelectOverlayTestNg, UpdateMenuInner002, TestSize.Level1)
3709 {
3710     /**
3711      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
3712      */
3713     SelectOverlayInfo selectInfo;
3714     selectInfo.singleLineHeight = NODE_ID;
3715     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3716     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3717     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3718     ASSERT_NE(selectOverlayNode, nullptr);
3719     /**
3720      * @tc.steps: step2. Create pattern and initialize HandleRegion
3721      */
3722     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3723     ASSERT_NE(pattern, nullptr);
3724     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
3725     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
3726     /**
3727      * @tc.steps: step3. Call UpdateMenuInner.
3728      * @tc.expected: return false
3729      */
3730 
3731     auto pipeline = PipelineContext::GetCurrentContext();
3732     CHECK_NULL_VOID(pipeline);
3733 
3734     selectOverlayNode->UpdateMenuInner(infoPtr);
3735     EXPECT_FALSE(selectOverlayNode->isExtensionMenu_);
3736 }
3737 
3738 /**
3739  * @tc.name: UpdateMenuInner003
3740  * @tc.desc: Test UpdateMenuInner
3741  * @tc.type: FUNC
3742  */
3743 HWTEST_F(SelectOverlayTestNg, UpdateMenuInner003, TestSize.Level1)
3744 {
3745     /**
3746      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
3747      */
3748     SelectOverlayInfo selectInfo;
3749     selectInfo.singleLineHeight = NODE_ID;
3750     auto menuOptionItems = GetMenuOptionItems();
3751     selectInfo.menuOptionItems = menuOptionItems;
3752     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3753     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3754     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3755     ASSERT_NE(selectOverlayNode, nullptr);
3756     /**
3757      * @tc.steps: step2. Create pattern and initialize HandleRegion
3758      */
3759     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3760     ASSERT_NE(pattern, nullptr);
3761     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
3762     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
3763     /**
3764      * @tc.steps: step3. Call UpdateMenuInner.
3765      * @tc.expected: return false
3766      */
3767     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0373502() 3768         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
3769     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
3770     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
3771 
3772     selectOverlayNode->UpdateMenuInner(infoPtr);
3773     EXPECT_FALSE(selectOverlayNode->isExtensionMenu_);
3774 }
3775 
3776 /**
3777  * @tc.name: UpdateMenuInner004
3778  * @tc.desc: Test UpdateMenuInner
3779  * @tc.type: FUNC
3780  */
3781 HWTEST_F(SelectOverlayTestNg, UpdateMenuInner004, TestSize.Level1)
3782 {
3783     /**
3784      * @tc.steps: step1. Create selectOverlayNode and initialize selectOverlayInfo properties.
3785      */
3786     SelectOverlayInfo selectInfo;
3787     selectInfo.singleLineHeight = NODE_ID;
3788     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3789     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3790     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3791     ASSERT_NE(selectOverlayNode, nullptr);
3792     /**
3793      * @tc.steps: step2. Create pattern and initialize HandleRegion
3794      */
3795     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
3796     ASSERT_NE(pattern, nullptr);
3797     pattern->firstHandleRegion_ = FIRST_HANDLE_REGION;
3798     pattern->secondHandleRegion_ = SECOND_HANDLE_REGION;
3799     /**
3800      * @tc.steps: step3. Call UpdateMenuInner.
3801      * @tc.expected: return false
3802      */
3803 
3804     auto pipeline = PipelineContext::GetCurrentContext();
3805     CHECK_NULL_VOID(pipeline);
3806 
3807     selectOverlayNode->UpdateMenuInner(infoPtr);
3808     EXPECT_FALSE(selectOverlayNode->isExtensionMenu_);
3809 }
3810 
3811 /**
3812  * @tc.name: ExecuteOverlayStatus003
3813  * @tc.desc: Test ExecuteOverlayStatus function.
3814  * @tc.type: FUNC
3815  */
3816 HWTEST_F(SelectOverlayTestNg, ExecuteOverlayStatus003, TestSize.Level1)
3817 {
3818     /**
3819      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
3820      */
3821     SelectOverlayInfo selectInfo;
3822     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3823     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3824     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3825     ASSERT_NE(selectOverlayNode, nullptr);
3826 
3827     /**
3828      * @tc.steps: step2. Create invalid type and call ExecuteOverlayStatus function.
3829      */
3830 
3831     selectOverlayNode->ExecuteOverlayStatus(FrameNodeType::BACKBUTTON, FrameNodeTrigger::HIDDEN);
3832     ASSERT_NE(selectOverlayNode, nullptr);
3833 }
3834 
3835 /**
3836  * @tc.name: ExecuteOverlayStatus002
3837  * @tc.desc: Test ExecuteOverlayStatus function.
3838  * @tc.type: FUNC
3839  */
3840 HWTEST_F(SelectOverlayTestNg, ExecuteOverlayStatus002, TestSize.Level1)
3841 {
3842     /**
3843      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
3844      */
3845     SelectOverlayInfo selectInfo;
3846     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3847     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3848     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3849     ASSERT_NE(selectOverlayNode, nullptr);
3850 
3851     /**
3852      * @tc.steps: step2. Create invalid type and call ExecuteOverlayStatus function.
3853      */
3854 
3855     selectOverlayNode->ExecuteOverlayStatus(FrameNodeType::EXTENSIONMENU, FrameNodeTrigger::HIDDEN);
3856     ASSERT_NE(selectOverlayNode, nullptr);
3857 }
3858 
3859 
3860 /**
3861  * @tc.name: AddSystemDefaultOptions007
3862  * @tc.desc: Test SelectOverlayNode AddSystemDefaultOptions.
3863  * @tc.type: FUNC
3864  */
3865 HWTEST_F(SelectOverlayTestNg, AddSystemDefaultOptions007, TestSize.Level1)
3866 {
3867     SelectOverlayInfo selectInfo;
3868     selectInfo.menuInfo.showCopy = true;
3869     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3870     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3871     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3872 
3873     float maxWidth = 8.0f;
3874     float allocatedSize = 11.0f;
3875     auto ret = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3876     EXPECT_TRUE(ret);
3877 }
3878 
3879 /**
3880  * @tc.name: AddSystemDefaultOptions008
3881  * @tc.desc: Test SelectOverlayNode AddSystemDefaultOptions.
3882  * @tc.type: FUNC
3883  */
3884 HWTEST_F(SelectOverlayTestNg, AddSystemDefaultOptions008, TestSize.Level1)
3885 {
3886     SelectOverlayInfo selectInfo;
3887     selectInfo.menuInfo.showCut = true;
3888     selectInfo.menuInfo.showCopy = true;
3889     selectInfo.menuInfo.menuDisable = true;
3890     selectInfo.menuInfo.showCameraInput = true;
3891     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3892     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3893     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3894     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3895     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3896     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
3897     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0373602() 3898         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
3899     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
3900 
3901     float maxWidth = 8.0f;
3902     float allocatedSize = 11.0f;
3903     auto ret = selectOverlayNode->AddSystemDefaultOptions(maxWidth, allocatedSize);
3904     EXPECT_TRUE(ret);
3905 }
3906 
3907 /**
3908  * @tc.name: ShowShare002
3909  * @tc.desc: Test SelectOverlayNode ShowShare.
3910  * @tc.type: FUNC
3911  */
3912 HWTEST_F(SelectOverlayTestNg, ShowShare002, TestSize.Level1)
3913 {
3914     SelectOverlayInfo selectInfo;
3915     selectInfo.menuInfo.showCut = true;
3916     selectInfo.menuInfo.showCopy = true;
3917     selectInfo.menuInfo.menuDisable = true;
3918     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3919     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3920     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3921 
3922     float maxWidth = 8.0f;
3923     float allocatedSize = 14.0f;
3924     selectOverlayNode->ShowShare(maxWidth, allocatedSize, infoPtr);
3925     EXPECT_TRUE(selectOverlayNode->isDefaultBtnOverMaxWidth_);
3926 }
3927 
3928 /**
3929  * @tc.name: ShowShare003
3930  * @tc.desc: Test SelectOverlayNode ShowShare.
3931  * @tc.type: FUNC
3932  */
3933 HWTEST_F(SelectOverlayTestNg, ShowShare003, TestSize.Level1)
3934 {
3935     SelectOverlayInfo selectInfo;
3936     selectInfo.menuInfo.showCut = true;
3937     selectInfo.menuInfo.showCopy = true;
3938     selectInfo.menuInfo.menuDisable = true;
3939     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3940     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3941     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3942 
3943     float maxWidth = 8.0f;
3944     float allocatedSize = 13.0f;
3945     selectOverlayNode->ShowShare(maxWidth, allocatedSize, infoPtr);
3946     EXPECT_TRUE(selectOverlayNode->isDefaultBtnOverMaxWidth_);
3947 }
3948 
3949 /**
3950  * @tc.name: ShowCamera001
3951  * @tc.desc: Test SelectOverlayNode ShowCamera.
3952  * @tc.type: FUNC
3953  */
3954 HWTEST_F(SelectOverlayTestNg, ShowCamera001, TestSize.Level1)
3955 {
3956     SelectOverlayInfo selectInfo;
3957     selectInfo.menuInfo.showCut = true;
3958     selectInfo.menuInfo.showCopy = true;
3959     selectInfo.menuInfo.menuDisable = true;
3960     selectInfo.menuInfo.showCameraInput = true;
3961     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3962     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3963     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3964     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3965     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3966     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
3967     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0373702() 3968         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
3969     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
3970 
3971     float maxWidth = 8.0f;
3972     float allocatedSize = 14.0f;
3973     selectOverlayNode->ShowCamera(maxWidth, allocatedSize, infoPtr);
3974     EXPECT_TRUE(selectOverlayNode->isDefaultBtnOverMaxWidth_);
3975 }
3976 
3977 /**
3978  * @tc.name: ShowCamera002
3979  * @tc.desc: Test SelectOverlayNode ShowCamera.
3980  * @tc.type: FUNC
3981  */
3982 HWTEST_F(SelectOverlayTestNg, ShowCamera002, TestSize.Level1)
3983 {
3984     SelectOverlayInfo selectInfo;
3985     selectInfo.menuInfo.showCut = true;
3986     selectInfo.menuInfo.showCopy = true;
3987     selectInfo.menuInfo.menuDisable = true;
3988     selectInfo.menuInfo.showCameraInput = true;
3989     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
3990     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
3991     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
3992     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3993     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3994     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
3995     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0373802() 3996         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
3997     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
3998 
3999     float maxWidth = 8.0f;
4000     float allocatedSize = 11.0f;
4001     selectOverlayNode->ShowCamera(maxWidth, allocatedSize, infoPtr);
4002     EXPECT_TRUE(selectOverlayNode->isDefaultBtnOverMaxWidth_);
4003 }
4004 
4005 /**
4006  * @tc.name: ShowCamera003
4007  * @tc.desc: Test SelectOverlayNode ShowCamera.
4008  * @tc.type: FUNC
4009  */
4010 HWTEST_F(SelectOverlayTestNg, ShowCamera003, TestSize.Level1)
4011 {
4012     SelectOverlayInfo selectInfo;
4013     selectInfo.menuInfo.showCut = true;
4014     selectInfo.menuInfo.showCopy = true;
4015     selectInfo.menuInfo.menuDisable = true;
4016     selectInfo.menuInfo.showCameraInput = true;
4017     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4018     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4019     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4020     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
4021     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
4022     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
4023     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0373902() 4024         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
4025     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
4026 
4027     float maxWidth = 8.0f;
4028     float allocatedSize = 80.0f;
4029     selectOverlayNode->ShowCamera(maxWidth, allocatedSize, infoPtr);
4030     EXPECT_TRUE(selectOverlayNode->isDefaultBtnOverMaxWidth_);
4031 }
4032 
4033 /**
4034  * @tc.name: SetSelectMenuHeight001
4035  * @tc.desc: Test SelectOverlayPattern SetSelectMenuHeight.
4036  * @tc.type: FUNC
4037  */
4038 HWTEST_F(SelectOverlayTestNg, SetSelectMenuHeight001, TestSize.Level1)
4039 {
4040     /**
4041      * @tc.steps: step1. Create selectOverlayNode and initialize properties.
4042      */
4043     SelectOverlayInfo selectInfo;
4044     selectInfo.menuInfo.menuDisable = true;
4045     selectInfo.menuInfo.showCut = false;
4046     selectInfo.menuInfo.showPaste = false;
4047     auto menuOptionItems = GetMenuOptionItems();
4048     selectInfo.menuOptionItems = menuOptionItems;
4049     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4050     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4051     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4052     EXPECT_NE(selectOverlayNode, nullptr);
4053 
4054     /**
4055      * @tc.steps: step2. Create pattern and call SetSelectMenuHeight function.
4056      */
4057     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
4058     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
4059     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
4060     selectOverlayNode->CreateToolBar();
4061     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
4062     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
4063     ASSERT_NE(pattern, nullptr);
4064     pattern->SetSelectMenuHeight();
4065 }
4066 
4067 /**
4068  * @tc.name: OverlayModifierOnDraw002
4069  * @tc.desc: Test SelectOverlayModifier OnDraw.
4070  * @tc.type: FUNC
4071  */
4072 HWTEST_F(SelectOverlayTestNg, OverlayModifierOnDraw002, TestSize.Level1)
4073 {
4074     /**
4075      * @tc.steps: step1. Create selectOverlayNode, pattern, canvas
4076      * and initialize properties.
4077      */
4078     SelectOverlayInfo selectInfo;
4079     selectInfo.menuInfo.menuDisable = true;
4080     selectInfo.menuInfo.showCut = false;
4081     selectInfo.menuInfo.showPaste = false;
4082     selectInfo.menuOptionItems = GetMenuOptionItems();
4083     selectInfo.singleLineHeight = NODE_ID;
4084     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
4085     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
4086     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
4087     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4088     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4089     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4090     EXPECT_NE(selectOverlayNode, nullptr);
4091     selectOverlayNode->CreateToolBar();
4092     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
4093     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<TextOverlayTheme>()));
4094     selectOverlayNode->backButton_ = FrameNode::GetOrCreateFrameNode("SelectMoreOrBackButton",
__anonede6c0373a02() 4095         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
4096     EXPECT_NE(selectOverlayNode->backButton_, nullptr);
4097     selectOverlayNode->AddExtensionMenuOptions(infoPtr, 0);
4098     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
4099     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
4100     EXPECT_NE(pattern, nullptr);
4101     pattern->CreateNodePaintMethod();
4102     auto overlayModifier = pattern->selectOverlayModifier_;
4103     EXPECT_NE(overlayModifier, nullptr);
4104     Testing::MockCanvas canvas;
4105     DrawingContext context = GetDrawingContext(canvas);
4106     for (int32_t i = 0; i < 4; i++) {
4107         overlayModifier->circleOffset_[i] = AceType::MakeRefPtr<AnimatablePropertyOffsetF>(offset);
4108         EXPECT_NE(overlayModifier->circleOffset_[i], nullptr);
4109         if (i < 4 - 1) {
4110             overlayModifier->lineEndOffset_[i] = AceType::MakeRefPtr<AnimatablePropertyOffsetF>(offset);
4111             EXPECT_NE(overlayModifier->lineEndOffset_[i], nullptr);
4112         }
4113     }
4114     overlayModifier->rotationAngle_ = AceType::MakeRefPtr<AnimatablePropertyFloat>(Dimension(1.75_vp).ConvertToPx());
4115     overlayModifier->SetMenuOptionOffset(offset);
4116     overlayModifier->pointRadius_ = AceType::MakeRefPtr<AnimatablePropertyFloat>(Dimension(1.75_vp).ConvertToPx());
4117     overlayModifier->SetHeadPointRadius(Dimension(1.0));
4118     overlayModifier->isNewAvoid_ = true;
4119     overlayModifier->SetFirstHandleIsShow(true);
4120     overlayModifier->SetSecondHandleIsShow(true);
4121     EXPECT_EQ(overlayModifier->firstHandleIsShow_->Get(), true);
4122     EXPECT_EQ(overlayModifier->secondHandleIsShow_->Get(), true);
4123     /**
4124      * @tc.steps: step2. call onDraw.
4125      * @tc.expected: cover branch isNewAvoid_, firstHandleIsShow_ and secondHandleIsShow_ are true.
4126      */
4127     overlayModifier->onDraw(context);
4128     EXPECT_EQ(overlayModifier->hasExtensionMenu_->Get(), false);
4129 }
4130 
4131 /**
4132  * @tc.name: OverlayModifierSetLineEndOffset001
4133  * @tc.desc: Test SelectOverlayModifier SetLineEndOffset.
4134  * @tc.type: FUNC
4135  */
4136 HWTEST_F(SelectOverlayTestNg, OverlayModifierSetLineEndOffset001, TestSize.Level1)
4137 {
4138     /**
4139      * @tc.steps: step1. Create and initialize selectOverlayNode, pattern.
4140      */
4141     SelectOverlayInfo selectInfo;
4142     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4143     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4144     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4145     ASSERT_NE(selectOverlayNode, nullptr);
4146     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
4147     ASSERT_NE(pattern, nullptr);
4148     pattern->CreateNodePaintMethod();
4149     auto overlayModifier = pattern->selectOverlayModifier_;
4150     EXPECT_NE(overlayModifier, nullptr);
4151     for (int32_t i = 0; i < 4; i++) {
4152         overlayModifier->circleOffset_[i] = AceType::MakeRefPtr<AnimatablePropertyOffsetF>(offset);
4153         EXPECT_NE(overlayModifier->circleOffset_[i], nullptr);
4154         if (i < 4 - 1) {
4155             overlayModifier->lineEndOffset_[i] = AceType::MakeRefPtr<AnimatablePropertyOffsetF>(offset);
4156             EXPECT_NE(overlayModifier->lineEndOffset_[i], nullptr);
4157         }
4158     }
4159     overlayModifier->rotationAngle_ = AceType::MakeRefPtr<AnimatablePropertyFloat>(Dimension(1.75_vp).ConvertToPx());
4160     overlayModifier->SetMenuOptionOffset(offset);
4161     overlayModifier->pointRadius_ = AceType::MakeRefPtr<AnimatablePropertyFloat>(Dimension(1.75_vp).ConvertToPx());
4162     overlayModifier->SetOtherPointRadius(Dimension(1.0));
4163     overlayModifier->SetHeadPointRadius(Dimension(1.0));
4164     /**
4165      * @tc.steps: step2. call SetLineEndOffset, when isMore is true.
4166      * @tc.expected: rotationAngle_ is 0.
4167      */
4168     overlayModifier->SetLineEndOffset(true);
4169     EXPECT_EQ(overlayModifier->rotationAngle_->Get(), 0);
4170     /**
4171      * @tc.steps: step3. call SetLineEndOffset, when isMore is false.
4172      * @tc.expected: rotationAngle_ isn't 0.
4173      */
4174     overlayModifier->SetLineEndOffset(false);
4175     EXPECT_NE(overlayModifier->rotationAngle_->Get(), 0);
4176 }
4177 
4178 /**
4179  * @tc.name: OverlayModifierSetHeadPointRadius001
4180  * @tc.desc: Test SelectOverlayModifier SetHeadPointRadius.
4181  * @tc.type: FUNC
4182  */
4183 HWTEST_F(SelectOverlayTestNg, OverlayModifierSetHeadPointRadius001, TestSize.Level1)
4184 {
4185     /**
4186      * @tc.steps: step1. Create and initialize selectOverlayNode, pattern.
4187      */
4188     SelectOverlayInfo selectInfo;
4189     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4190     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4191     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4192     ASSERT_NE(selectOverlayNode, nullptr);
4193     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
4194     ASSERT_NE(pattern, nullptr);
4195     pattern->CreateNodePaintMethod();
4196     auto overlayModifier = pattern->selectOverlayModifier_;
4197     EXPECT_NE(overlayModifier, nullptr);
4198     /**
4199      * @tc.steps: step2. call SetOtherPointRadius and SetHeadPointRadius.
4200      * @tc.expected: pointRadius_ and headPointRadius_ have value.
4201      */
4202     overlayModifier->SetOtherPointRadius(Dimension(1.0));
4203     overlayModifier->SetHeadPointRadius(Dimension(1.0));
4204     EXPECT_EQ(overlayModifier->pointRadius_->Get(), 1.0);
4205     EXPECT_EQ(overlayModifier->headPointRadius_->Get(), 1.0);
4206     /**
4207      * @tc.steps: step3. call SetOtherPointRadius and SetHeadPointRadius.
4208      * @tc.expected: pointRadius_ and headPointRadius_ are nullptr.
4209      */
4210     overlayModifier->pointRadius_ = nullptr;
4211     overlayModifier->headPointRadius_ = nullptr;
4212     overlayModifier->SetOtherPointRadius(Dimension(1.0));
4213     overlayModifier->SetHeadPointRadius(Dimension(1.0));
4214     EXPECT_EQ(overlayModifier->headPointRadius_, nullptr);
4215     EXPECT_EQ(overlayModifier->pointRadius_, nullptr);
4216 }
4217 
4218 /**
4219  * @tc.name: GetCreateMenuOptionsParams001
4220  * @tc.desc: Test select_overlay_test_ng GetCreateMenuOptionsParams.
4221  * @tc.type: FUNC
4222  */
4223 HWTEST_F(SelectOverlayTestNg, GetCreateMenuOptionsParams001, TestSize.Level1)
4224 {
4225     /**
4226      * @tc.steps: step1. Create and initialize selectOverlayNode, pattern.
4227      */
4228     auto OnCreateMenuCallback =
__anonede6c0373b02(const std::vector<NG::MenuItemParam>& systemMenuItems) 4229         [](const std::vector<NG::MenuItemParam>& systemMenuItems) -> std::vector<NG::MenuOptionsParam> {
4230         std::vector<MenuOptionsParam> menuParams;
4231         MenuOptionsParam menuItem1;
4232         menuItem1.content = "item1";
4233         menuItem1.id = "item1";
4234         menuParams.emplace_back(menuItem1);
4235 
4236         MenuOptionsParam menuItem2;
4237         menuItem1.content = "item2";
4238         menuItem1.id = "item2";
4239         menuParams.emplace_back(menuItem2);
4240         return menuParams;
4241     };
__anonede6c0373c02(NG::MenuItemParam menuOptionsParam) 4242     auto onMenuItemClick = [](NG::MenuItemParam menuOptionsParam) -> bool {
4243         return false;
4244     };
4245     SelectOverlayInfo selectInfo;
4246     selectInfo.menuInfo.menuIsShow = true;
4247     selectInfo.menuInfo.showCameraInput = true;
4248     selectInfo.menuOptionItems = GetMenuOptionItems();
4249     selectInfo.onCreateCallback.onMenuItemClick = onMenuItemClick;
4250     selectInfo.onCreateCallback.onCreateMenuCallback = OnCreateMenuCallback;
4251     auto info_ = std::make_shared<SelectOverlayInfo>(selectInfo);
4252 
4253     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(info_);
4254     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4255     ASSERT_NE(selectOverlayNode, nullptr);
4256     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
4257     ASSERT_NE(pattern, nullptr);
4258     pattern->CreateNodePaintMethod();
4259     auto overlayModifier = pattern->selectOverlayModifier_;
4260     EXPECT_NE(overlayModifier, nullptr);
4261     std::vector<MenuOptionsParam> menuOptionItems;
4262     for (int32_t i = 0; i < 10; i++) {
4263         MenuOptionsParam item;
4264         item.id = std::to_string(i);
4265         item.content = std::to_string(i);
4266         menuOptionItems.push_back(item);
4267     }
4268     auto menuWrapper =  selectOverlayNode->CreateMenuNode(info_);
4269     EXPECT_NE(menuWrapper, nullptr);
4270 }
4271 
4272 /**
4273  * @tc.name: LandscapeMenuAddMenuOptions001
4274  * @tc.desc: Test select_overlay_test_ng LandscapeMenuAddMenuOptions.
4275  * @tc.type: FUNC
4276  */
4277 HWTEST_F(SelectOverlayTestNg, LandscapeMenuAddMenuOptions001, TestSize.Level1)
4278 {
4279     /**
4280      * @tc.steps: step1.  CreateMenuNodeSuccess.
4281      */
4282     SelectOverlayInfo selectInfo;
4283     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4284     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4285     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4286     ASSERT_NE(selectOverlayNode, nullptr);
4287     std::vector<MenuOptionsParam> menuOptionItems;
4288     MenuOptionsParam menuItem1;
4289     menuItem1.content = "item1";
4290     menuItem1.id = "item1";
4291     menuOptionItems.emplace_back(menuItem1);
4292 
4293     MenuOptionsParam menuItem2;
4294     menuItem2.content = "item2";
4295     menuItem2.id = "item2";
4296     menuOptionItems.emplace_back(menuItem2);
4297 
4298     int32_t extensionOptionStartIndex = -1;
4299     selectOverlayNode->LandscapeMenuAddMenuOptions(menuOptionItems, false, 300.0, 200.0, extensionOptionStartIndex);
4300     EXPECT_EQ(extensionOptionStartIndex, -1);
4301 }
4302 
4303 /**
4304  * @tc.name: LandscapeMenuAddMenuOptions002
4305  * @tc.desc: Test select_overlay_test_ng LandscapeMenuAddMenuOptions.
4306  * @tc.type: FUNC
4307  */
4308 HWTEST_F(SelectOverlayTestNg, LandscapeMenuAddMenuOptions002, TestSize.Level1)
4309 {
4310     /**
4311      * @tc.steps: step1.  CreateMenuNodeSuccess.
4312      */
4313     SelectOverlayInfo selectInfo;
4314     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4315     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4316     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4317     ASSERT_NE(selectOverlayNode, nullptr);
4318     std::vector<MenuOptionsParam> menuOptionItems;
4319     MenuOptionsParam menuItem1;
4320     menuItem1.content = "item1";
4321     menuItem1.id = "item1";
4322     menuOptionItems.emplace_back(menuItem1);
4323 
4324     MenuOptionsParam menuItem2;
4325     menuItem2.content = "item2";
4326     menuItem2.id = "item2";
4327     menuOptionItems.emplace_back(menuItem2);
4328 
4329     int32_t extensionOptionStartIndex = -1;
4330     selectOverlayNode->LandscapeMenuAddMenuOptions(menuOptionItems, false, 300.0, 320.0, extensionOptionStartIndex);
4331     EXPECT_EQ(extensionOptionStartIndex, 0);
4332 }
4333 
4334 /**
4335  * @tc.name: GetSystemMenuItemParams001
4336  * @tc.desc: Test select_overlay_test_ng GetSystemMenuItemParams.
4337  * @tc.type: FUNC
4338  */
4339 HWTEST_F(SelectOverlayTestNg, GetSystemMenuItemParams001, TestSize.Level1)
4340 {
4341     /**
4342      * @tc.steps: step1.  CreateMenuNodeSuccess.
4343      */
4344     SelectOverlayInfo info;
4345     info.menuInfo.showCopy = true;
4346     info.menuInfo.showPaste = true;
4347     info.menuInfo.showCut = true;
4348     info.menuInfo.showCopyAll = true;
4349     info.menuInfo.showCameraInput = true;
4350     auto params = SelectOverlayNode::GetSystemMenuItemParams(std::make_shared<SelectOverlayInfo>(info));
4351     EXPECT_EQ(params.size(), 5);
4352 }
4353 
4354 /**
4355  * @tc.name: GetSystemMenuItemParams002
4356  * @tc.desc: Test select_overlay_test_ng GetSystemMenuItemParams.
4357  * @tc.type: FUNC
4358  */
4359 HWTEST_F(SelectOverlayTestNg, GetSystemMenuItemParams002, TestSize.Level1)
4360 {
4361     /**
4362      * @tc.steps: step1.  CreateMenuNodeSuccess.
4363      */
4364     SelectOverlayInfo info;
4365     info.menuInfo.showCopy = false;
4366     info.menuInfo.showPaste = false;
4367     info.menuInfo.showCut = false;
4368     info.menuInfo.showCopyAll = false;
4369     info.menuInfo.showCameraInput = false;
4370     auto params = SelectOverlayNode::GetSystemMenuItemParams(std::make_shared<SelectOverlayInfo>(info));
4371     EXPECT_EQ(params.size(), 0);
4372 }
4373 
4374 /**
4375  * @tc.name: GetSystemMenuItemParams003
4376  * @tc.desc: Test select_overlay_test_ng GetSystemMenuItemParams.
4377  * @tc.type: FUNC
4378  */
4379 HWTEST_F(SelectOverlayTestNg, GetSystemMenuItemParams003, TestSize.Level1)
4380 {
4381     /**
4382      * @tc.steps: step1.  CreateMenuNodeSuccess.
4383      */
4384     SelectOverlayInfo info;
4385     info.menuInfo.showCopy = true;
4386     info.menuInfo.showPaste = false;
4387     info.menuInfo.showCut = true;
4388     info.menuInfo.showCopyAll = false;
4389     info.menuInfo.showCameraInput = true;
4390     auto params = SelectOverlayNode::GetSystemMenuItemParams(std::make_shared<SelectOverlayInfo>(info));
4391     EXPECT_EQ(params.size(), 3);
4392 }
4393 
4394 /**
4395  * @tc.name: GetSystemMenuItemParams004
4396  * @tc.desc: Test select_overlay_test_ng GetSystemMenuItemParams.
4397  * @tc.type: FUNC
4398  */
4399 HWTEST_F(SelectOverlayTestNg, GetSystemMenuItemParams004, TestSize.Level1)
4400 {
4401     /**
4402      * @tc.steps: step1.  CreateMenuNodeSuccess.
4403      */
4404     SelectOverlayInfo info;
4405     info.menuInfo.showCopy = false;
4406     info.menuInfo.showPaste = true;
4407     info.menuInfo.showCut = false;
4408     info.menuInfo.showCopyAll = true;
4409     info.menuInfo.showCameraInput = false;
4410     auto params = SelectOverlayNode::GetSystemMenuItemParams(std::make_shared<SelectOverlayInfo>(info));
4411     EXPECT_EQ(params.size(), 2);
4412 }
4413 
4414 /**
4415  * @tc.name: GetSystemMenuItemParams005
4416  * @tc.desc: Test select_overlay_test_ng GetSystemMenuItemParams.
4417  * @tc.type: FUNC
4418  */
4419 HWTEST_F(SelectOverlayTestNg, GetSystemMenuItemParams005, TestSize.Level1)
4420 {
4421     /**
4422      * @tc.steps: step1.  CreateMenuNodeSuccess.
4423      */
4424     SelectOverlayInfo info;
4425     info.menuInfo.showCopy = false;
4426     info.menuInfo.showPaste = true;
4427     info.menuInfo.showCut = false;
4428     info.menuInfo.showCopyAll = false;
4429     info.menuInfo.showCameraInput = false;
4430     auto params = SelectOverlayNode::GetSystemMenuItemParams(std::make_shared<SelectOverlayInfo>(info));
4431     EXPECT_EQ(params.size(), 1);
4432 }
4433 
4434 /**
4435  * @tc.name: GetSystemMenuItemParams006
4436  * @tc.desc: Test select_overlay_test_ng GetSystemMenuItemParams.
4437  * @tc.type: FUNC
4438  */
4439 HWTEST_F(SelectOverlayTestNg, GetSystemMenuItemParams006, TestSize.Level1)
4440 {
4441     /**
4442      * @tc.steps: step1.  CreateMenuNodeSuccess.
4443      */
4444     SelectOverlayInfo info;
4445     info.menuInfo.showCopy = false;
4446     info.menuInfo.showPaste = true;
4447     info.menuInfo.showCut = true;
4448     info.menuInfo.showCopyAll = true;
4449     info.menuInfo.showCameraInput = true;
4450     auto params = SelectOverlayNode::GetSystemMenuItemParams(std::make_shared<SelectOverlayInfo>(info));
4451     EXPECT_EQ(params.size(), 4);
4452 }
4453 
4454 /**
4455  * @tc.name: AddCreateMenuItems001
4456  * @tc.desc: Test select_overlay_test_ng AddCreateMenuItems.
4457  * @tc.type: FUNC
4458  */
4459 HWTEST_F(SelectOverlayTestNg, AddCreateMenuItems001, TestSize.Level1)
4460 {
4461     /**
4462      * @tc.steps: step1.  CreateMenuNodeSuccess.
4463      */
4464     SelectOverlayInfo selectInfo;
4465     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4466     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4467     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4468     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
4469     std::vector<MenuOptionsParam> menuOptionItems;
4470     MenuOptionsParam menuItem1;
4471     menuItem1.content = "item1";
4472     menuItem1.id = "item1";
4473     menuOptionItems.emplace_back(menuItem1);
4474 
4475     MenuOptionsParam menuItem2;
4476     menuItem2.content = "item2";
4477     menuItem2.id = "item2";
4478     menuOptionItems.emplace_back(menuItem2);
4479 
4480     MenuOptionsParam menuItem3;
4481     menuItem3.content = "item3";
4482     menuItem3.id = "item3";
4483     menuOptionItems.emplace_back(menuItem3);
4484 
4485     MenuOptionsParam menuItem4;
4486     menuItem4.content = "OH_DEFAULT_PASTE";
4487     menuItem4.id = "OH_DEFAULT_PASTE";
4488     menuOptionItems.emplace_back(menuItem4);
4489 
4490     auto info = pattern->GetSelectOverlayInfo();
4491 
4492     float maxWidth = 100.0f;
4493     int32_t index = selectOverlayNode->AddCreateMenuItems(menuOptionItems, info, maxWidth);
4494     EXPECT_EQ(index, 3);
4495 }
4496 
4497 /**
4498  * @tc.name: CreatExtensionMenu001
4499  * @tc.desc: Test select_overlay_test_ng CreatExtensionMenu.
4500  * @tc.type: FUNC
4501  */
4502 HWTEST_F(SelectOverlayTestNg, CreatExtensionMenu001, TestSize.Level1)
4503 {
4504     /**
4505      * @tc.steps: step1.  CreateMenuNodeSuccess.
4506      */
4507     SelectOverlayInfo selectInfo;
4508     auto infoPtr = std::make_shared<SelectOverlayInfo>(selectInfo);
4509     auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(infoPtr);
4510     auto selectOverlayNode = AceType::DynamicCast<SelectOverlayNode>(frameNode);
4511     auto pattern = selectOverlayNode->GetPattern<SelectOverlayPattern>();
4512     std::vector<OptionParam> params;
4513     selectOverlayNode->CreatExtensionMenu(std::move(params));
4514     EXPECT_NE(selectOverlayNode->selectMenu_, nullptr);
4515 }
4516 } // namespace OHOS::Ace::NG
4517