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 
16 #include <functional>
17 #include <optional>
18 #include <string>
19 
20 #include "gtest/gtest.h"
21 
22 #define private public
23 #define protected public
24 #include "test/mock/core/common/mock_theme_default.h"
25 #include "test/mock/core/common/mock_theme_manager.h"
26 #include "test/mock/core/pipeline/mock_pipeline_context.h"
27 #include "test/mock/base/mock_task_executor.h"
28 #include "test/mock/core/common/mock_container.h"
29 #include "test/mock/core/rosen/mock_canvas.h"
30 
31 #include "base/geometry/dimension.h"
32 #include "base/geometry/ng/size_t.h"
33 #include "base/i18n/localization.h"
34 #include "base/memory/ace_type.h"
35 #include "base/memory/referenced.h"
36 #include "base/utils/measure_util.h"
37 #include "core/components/picker/picker_theme.h"
38 #include "core/components/theme/icon_theme.h"
39 #include "core/components_ng/base/frame_node.h"
40 #include "core/components_ng/base/view_stack_processor.h"
41 #include "core/components_ng/layout/layout_algorithm.h"
42 #include "core/components_ng/layout/layout_property.h"
43 #include "core/components_ng/pattern/button/button_layout_property.h"
44 #include "core/components_ng/pattern/button/button_pattern.h"
45 #include "core/components_ng/pattern/image/image_pattern.h"
46 #include "core/components_ng/pattern/pattern.h"
47 #include "core/components_ng/pattern/stack/stack_pattern.h"
48 #include "core/components_ng/pattern/text/text_pattern.h"
49 #include "core/components_ng/pattern/text_picker/textpicker_column_pattern.h"
50 #include "core/components_ng/pattern/text_picker/textpicker_dialog_view.h"
51 #include "core/components_ng/pattern/text_picker/textpicker_model.h"
52 #include "core/components_ng/pattern/text_picker/textpicker_model_ng.h"
53 #include "core/components_ng/pattern/text_picker/textpicker_pattern.h"
54 #include "core/components_v2/inspector/inspector_constants.h"
55 #include "core/pipeline/base/element_register.h"
56 #include "core/pipeline_ng/ui_task_scheduler.h"
57 #undef private
58 #undef protected
59 
60 using namespace testing;
61 using namespace testing::ext;
62 
63 namespace OHOS::Ace::NG {
64 namespace {
65 const InspectorFilter filter;
66 constexpr size_t SECOND = 2;
67 constexpr uint32_t SELECTED_INDEX_1 = 1;
68 constexpr double FONT_SIZE_5 = 5.0;
69 constexpr double FONT_SIZE_10 = 10.0;
70 constexpr double FONT_SIZE_20 = 20.0;
71 const std::string EMPTY_TEXT = "";
72 const std::string TEXT_PICKER_CONTENT = "text";
73 const OffsetF CHILD_OFFSET(0.0f, 10.0f);
74 const SizeF TEST_TEXT_FRAME_SIZE { 100.0f, 10.0f };
75 const SizeF COLUMN_SIZE { 100.0f, 200.0f };
76 } // namespace
77 
78 class TextPickerPatternTestNg : public testing::Test {
79 public:
80     static void SetUpTestSuite();
81     static void TearDownTestSuite();
82     void SetUp() override;
83     void TearDown() override;
84     void InitTextPickerPatternTestNg();
85     void DestroyTextPickerPatternTestNgObject();
86 
87     RefPtr<FrameNode> frameNode_;
88     RefPtr<TextPickerPattern> textPickerPattern_;
89     RefPtr<TextPickerAccessibilityProperty> textPickerAccessibilityProperty_;
90     RefPtr<TextPickerRowAccessibilityProperty> textPickerRowAccessibilityProperty_;
91     RefPtr<FrameNode> stackNode_;
92     RefPtr<FrameNode> blendNode_;
93     RefPtr<FrameNode> columnNode_;
94     RefPtr<TextPickerColumnPattern> textPickerColumnPattern_;
95     RefPtr<FrameNode> stackNodeNext_;
96     RefPtr<FrameNode> blendNodeNext_;
97     RefPtr<FrameNode> columnNodeNext_;
98     RefPtr<TextPickerColumnPattern> textPickerColumnPatternNext_;
99     RefPtr<TextPickerAccessibilityProperty> textPickerAccessibilityPropertyNext_;
100 };
101 
DestroyTextPickerPatternTestNgObject()102 void TextPickerPatternTestNg::DestroyTextPickerPatternTestNgObject()
103 {
104     frameNode_ = nullptr;
105     textPickerPattern_ = nullptr;
106     textPickerAccessibilityProperty_ = nullptr;
107     textPickerRowAccessibilityProperty_ = nullptr;
108     stackNode_ = nullptr;
109     blendNode_ = nullptr;
110     columnNode_ = nullptr;
111     textPickerColumnPattern_ = nullptr;
112     stackNodeNext_ = nullptr;
113     blendNodeNext_ = nullptr;
114     columnNodeNext_ = nullptr;
115     textPickerColumnPatternNext_ = nullptr;
116     textPickerAccessibilityPropertyNext_ = nullptr;
117 }
118 
InitTextPickerPatternTestNg()119 void TextPickerPatternTestNg::InitTextPickerPatternTestNg()
120 {
121     frameNode_ = FrameNode::GetOrCreateFrameNode(V2::TEXT_PICKER_ETS_TAG,
122         ViewStackProcessor::GetInstance()->ClaimNodeId(), []() { return AceType::MakeRefPtr<TextPickerPattern>(); });
123     ASSERT_NE(frameNode_, nullptr);
124     textPickerRowAccessibilityProperty_ = frameNode_->GetAccessibilityProperty<TextPickerRowAccessibilityProperty>();
125     ASSERT_NE(textPickerRowAccessibilityProperty_, nullptr);
126     textPickerPattern_ = frameNode_->GetPattern<TextPickerPattern>();
127     ASSERT_NE(textPickerPattern_, nullptr);
128     stackNode_ = FrameNode::GetOrCreateFrameNode(V2::STACK_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
129         []() { return AceType::MakeRefPtr<StackPattern>(); });
130     ASSERT_NE(stackNode_, nullptr);
131     blendNode_ = FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
132         []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
133     ASSERT_NE(blendNode_, nullptr);
134     columnNode_ = FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
135         []() { return AceType::MakeRefPtr<TextPickerColumnPattern>(); });
136     ASSERT_NE(columnNode_, nullptr);
137     textPickerAccessibilityProperty_ = columnNode_->GetAccessibilityProperty<TextPickerAccessibilityProperty>();
138     ASSERT_NE(textPickerAccessibilityProperty_, nullptr);
139     textPickerColumnPattern_ = columnNode_->GetPattern<TextPickerColumnPattern>();
140     ASSERT_NE(textPickerColumnPattern_, nullptr);
141     columnNode_->MountToParent(blendNode_);
142     blendNode_->MountToParent(stackNode_);
143     stackNode_->MountToParent(frameNode_);
144 
145     stackNodeNext_ = FrameNode::GetOrCreateFrameNode(V2::STACK_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
146         []() { return AceType::MakeRefPtr<StackPattern>(); });
147     ASSERT_NE(stackNodeNext_, nullptr);
148     blendNodeNext_ = FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
149         []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
150     ASSERT_NE(blendNodeNext_, nullptr);
151     columnNodeNext_ =
152         FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
153             []() { return AceType::MakeRefPtr<TextPickerColumnPattern>(); });
154     ASSERT_NE(columnNodeNext_, nullptr);
155     textPickerAccessibilityPropertyNext_ = columnNode_->GetAccessibilityProperty<TextPickerAccessibilityProperty>();
156     ASSERT_NE(textPickerAccessibilityPropertyNext_, nullptr);
157     textPickerColumnPatternNext_ = columnNodeNext_->GetPattern<TextPickerColumnPattern>();
158     ASSERT_NE(textPickerColumnPatternNext_, nullptr);
159     columnNodeNext_->MountToParent(blendNodeNext_);
160     blendNodeNext_->MountToParent(stackNodeNext_);
161     stackNodeNext_->MountToParent(frameNode_);
162 }
163 
SetUpTestSuite()164 void TextPickerPatternTestNg::SetUpTestSuite()
165 {
166     MockPipelineContext::SetUp();
167     MockContainer::SetUp();
168     MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
169     MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrentContext();
170 }
171 
TearDownTestSuite()172 void TextPickerPatternTestNg::TearDownTestSuite()
173 {
174     MockPipelineContext::TearDown();
175     MockContainer::TearDown();
176 }
177 
SetUp()178 void TextPickerPatternTestNg::SetUp()
179 {
180     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
181     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly([](ThemeType type) -> RefPtr<Theme> {
182         if (type == IconTheme::TypeId()) {
183             return AceType::MakeRefPtr<IconTheme>();
184         } else if (type == DialogTheme::TypeId()) {
185             return AceType::MakeRefPtr<DialogTheme>();
186         } else if (type == PickerTheme::TypeId()) {
187             return MockThemeDefault::GetPickerTheme();
188         } else {
189             return nullptr;
190         }
191     });
192     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
193 }
194 
TearDown()195 void TextPickerPatternTestNg::TearDown()
196 {
197     MockPipelineContext::GetCurrent()->themeManager_ = nullptr;
198     ViewStackProcessor::GetInstance()->ClearStack();
199 }
200 
201 class TestNode : public UINode {
202     DECLARE_ACE_TYPE(TestNode, UINode);
203 
204 public:
CreateTestNode(int32_t nodeId)205     static RefPtr<TestNode> CreateTestNode(int32_t nodeId)
206     {
207         auto spanNode = MakeRefPtr<TestNode>(nodeId);
208         return spanNode;
209     }
210 
IsAtomicNode() const211     bool IsAtomicNode() const override
212     {
213         return true;
214     }
215 
TestNode(int32_t nodeId)216     explicit TestNode(int32_t nodeId) : UINode("TestNode", nodeId) {}
217     ~TestNode() override = default;
218 };
219 
220 /**
221  * @tc.name: TextPickerPatternToJsonValue001
222  * @tc.desc: Test TextPickerPattern ToJsonValue(range is not empty).
223  * @tc.type: FUNC
224  */
225 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternToJsonValue001, TestSize.Level1)
226 {
227     auto pipeline = MockPipelineContext::GetCurrent();
228     auto theme = pipeline->GetTheme<PickerTheme>();
229 
230     SystemProperties::SetDeviceType(DeviceType::PHONE);
231     SystemProperties::SetDeviceOrientation(static_cast<int32_t>(DeviceOrientation::LANDSCAPE));
232     TextPickerModelNG::GetInstance()->Create(theme, MIXTURE);
233     std::vector<NG::RangeContent> range = { { "/demo/demo1.jpg", "test1" }, { "/demo/demo2.jpg", "test2" },
234         { "/demo/demo3.jpg", "test3" } };
235     TextPickerModelNG::GetInstance()->SetRange(range);
236     TextPickerModelNG::GetInstance()->SetSelected(SELECTED_INDEX_1);
237     PickerTextStyle disappearTextStyle;
238     disappearTextStyle.fontSize = Dimension(FONT_SIZE_5);
239     disappearTextStyle.textColor = Color::BLACK;
240     TextPickerModelNG::GetInstance()->SetDisappearTextStyle(theme, disappearTextStyle);
241     PickerTextStyle textStyle;
242     textStyle.fontSize = Dimension(FONT_SIZE_10);
243     textStyle.textColor = Color::BLUE;
244     TextPickerModelNG::GetInstance()->SetNormalTextStyle(theme, textStyle);
245     PickerTextStyle selectedTextStyle;
246     selectedTextStyle.fontSize = Dimension(FONT_SIZE_20);
247     selectedTextStyle.textColor = Color::RED;
248     TextPickerModelNG::GetInstance()->SetSelectedTextStyle(theme, selectedTextStyle);
249     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
250     ASSERT_NE(frameNode, nullptr);
251     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
252     std::unique_ptr<JsonValue> json = std::make_unique<JsonValue>();
253     textPickerPattern->ToJsonValue(json, filter);
254     ASSERT_NE(json, nullptr);
255 }
256 
257 /**
258  * @tc.name: TextPickerPatternToJsonValue002
259  * @tc.desc: Test TextPickerPattern ToJsonValue(range is empty).
260  * @tc.type: FUNC
261  */
262 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternToJsonValue002, TestSize.Level1)
263 {
264     auto pipeline = MockPipelineContext::GetCurrent();
265     auto theme = pipeline->GetTheme<PickerTheme>();
266 
267     SystemProperties::SetDeviceType(DeviceType::PHONE);
268     SystemProperties::SetDeviceOrientation(static_cast<int32_t>(DeviceOrientation::LANDSCAPE));
269     TextPickerModelNG::GetInstance()->Create(theme, MIXTURE);
270     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
271     ASSERT_NE(frameNode, nullptr);
272     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
273     std::unique_ptr<JsonValue> json = std::make_unique<JsonValue>();
274     textPickerPattern->ToJsonValue(json, filter);
275     ASSERT_NE(json, nullptr);
276 }
277 
278 /**
279  * @tc.name: TextPickerPattern ToJsonValue003
280  * @tc.desc: Test TextPickerPattern ToJsonValue(isCascade_ is false).
281  * @tc.type: FUNC
282  */
283 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternToJsonValue003, TestSize.Level1)
284 {
285     auto pipeline = MockPipelineContext::GetCurrent();
286     auto theme = pipeline->GetTheme<PickerTheme>();
287 
288     SystemProperties::SetDeviceType(DeviceType::PHONE);
289     SystemProperties::SetDeviceOrientation(static_cast<int32_t>(DeviceOrientation::LANDSCAPE));
290     TextPickerModelNG::GetInstance()->Create(theme, MIXTURE);
291 
292     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
293     ASSERT_NE(frameNode, nullptr);
294     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
295 
296     /**
297      * @tc.cases: case. cover cascadeOriginptions_ is not empty
298      */
299     NG::TextCascadePickerOptions option;
300     option.rangeResult = { "rangeResult1", "rangeResult2" };
301     std::vector<NG::TextCascadePickerOptions> options;
302     options.emplace_back(option);
303 
304     textPickerPattern->SetCascadeOptions(options, options);
305     std::unique_ptr<JsonValue> json = std::make_unique<JsonValue>();
306 
307     /**
308      * @tc.cases: case. cover isCascade_ == false
309      */
310     textPickerPattern->SetIsCascade(false);
311     textPickerPattern->ToJsonValue(json, filter);
312     ASSERT_NE(json, nullptr);
313 
314     /**
315      * @tc.cases: case. cover isCascade_ == true
316      */
317     textPickerPattern->SetIsCascade(true);
318     textPickerPattern->ToJsonValue(json, filter);
319     ASSERT_NE(json, nullptr);
320 }
321 
322 /**
323  * @tc.name: TextPickerPatternProcessDepth001
324  * @tc.desc: Test TextPickerPattern ProcessCascadeOptionDepth(child is empty).
325  * @tc.type: FUNC
326  */
327 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternProcessDepth001, TestSize.Level1)
328 {
329     auto pipeline = MockPipelineContext::GetCurrent();
330     auto theme = pipeline->GetTheme<PickerTheme>();
331 
332     SystemProperties::SetDeviceType(DeviceType::PHONE);
333     SystemProperties::SetDeviceOrientation(static_cast<int32_t>(DeviceOrientation::LANDSCAPE));
334     /**
335      * @tc.step: step1. create textpicker pattern.
336      */
337     TextPickerModelNG::GetInstance()->MultiInit(theme);
338     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
339     ASSERT_NE(frameNode, nullptr);
340     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
341     NG::TextCascadePickerOptions option;
342     option.rangeResult = { "1", "2", "3" };
343     /**
344      * @tc.step: step2. create cascade option and call it.
345      * @tc.expected: caculate the option depth, the depth is correct.
346      */
347     auto depth = textPickerPattern->ProcessCascadeOptionDepth(option);
348     EXPECT_EQ(1, depth);
349 }
350 
351 /**
352  * @tc.name: TextPickerPatternProcessDepth002
353  * @tc.desc: Test TextPickerPattern ProcessCascadeOptionDepth.
354  * @tc.type: FUNC
355  */
356 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternProcessDepth002, TestSize.Level1)
357 {
358     auto pipeline = MockPipelineContext::GetCurrent();
359     auto theme = pipeline->GetTheme<PickerTheme>();
360 
361     SystemProperties::SetDeviceType(DeviceType::PHONE);
362     SystemProperties::SetDeviceOrientation(static_cast<int32_t>(DeviceOrientation::LANDSCAPE));
363     /**
364      * @tc.step: step1. create textpicker pattern.
365      */
366     TextPickerModelNG::GetInstance()->MultiInit(theme);
367     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
368     ASSERT_NE(frameNode, nullptr);
369     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
370     /**
371      * @tc.step: step2. create cascade option and call it.
372      * @tc.expected: caculate the option depth, the depth is correct.
373      */
374     NG::TextCascadePickerOptions option;
375     option.rangeResult = { "1", "2", "3" };
376     NG::TextCascadePickerOptions childoption;
377     childoption.rangeResult = { "11", "12", "13" };
378     option.children.emplace_back(childoption);
379     auto depth = textPickerPattern->ProcessCascadeOptionDepth(option);
380     EXPECT_EQ(SECOND, depth);
381 }
382 
383 /**
384  * @tc.name: TextPickerPatternTest001
385  * @tc.desc: test OnKeyEvent
386  * @tc.type: FUNC
387  */
388 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest001, TestSize.Level1)
389 {
390     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
391     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
392     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
393     ASSERT_NE(frameNode, nullptr);
394     auto focusHub = frameNode->GetEventHub<NG::TextPickerEventHub>()->GetOrCreateFocusHub();
395     frameNode->MarkModifyDone();
396     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
397     ASSERT_NE(pickerProperty, nullptr);
398 
399     /**
400      * @tc.cases: case1. up KeyEvent.
401      */
402     KeyEvent keyEventUp(KeyCode::KEY_DPAD_UP, KeyAction::DOWN);
403     EXPECT_TRUE(focusHub->ProcessOnKeyEventInternal(keyEventUp));
404 
405     /**
406      * @tc.cases: case1. down KeyEvent.
407      */
408     KeyEvent keyEventDown(KeyCode::KEY_DPAD_DOWN, KeyAction::DOWN);
409     EXPECT_TRUE(focusHub->ProcessOnKeyEventInternal(keyEventDown));
410 }
411 
412 /**
413  * @tc.name: TextPickerPatternTest002
414  * @tc.desc: test OnKeyEvent
415  * @tc.type: FUNC
416  */
417 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest002, TestSize.Level1)
418 {
419     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
420     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
421     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
422     ASSERT_NE(frameNode, nullptr);
423     auto focusHub = frameNode->GetEventHub<NG::TextPickerEventHub>()->GetOrCreateFocusHub();
424     frameNode->MarkModifyDone();
425     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
426     ASSERT_NE(pickerProperty, nullptr);
427 
428     /**
429      * @tc.cases: case1. left KeyEvent.
430      */
431     KeyEvent keyEventLeft(KeyCode::KEY_DPAD_LEFT, KeyAction::DOWN);
432     EXPECT_TRUE(focusHub->ProcessOnKeyEventInternal(keyEventLeft));
433 
434     /**
435      * @tc.cases: case1. right KeyEvent.
436      */
437     KeyEvent keyEventRight(KeyCode::KEY_DPAD_RIGHT, KeyAction::DOWN);
438     EXPECT_TRUE(focusHub->ProcessOnKeyEventInternal(keyEventRight));
439 }
440 
441 /**
442  * @tc.name: TextPickerPatternTest003
443  * @tc.desc: test OnDirtyLayoutWrapperSwap
444  * @tc.type: FUNC
445  */
446 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest003, TestSize.Level1)
447 {
448     /**
449      * @tc.step: step1. create textpicker framenode and pattern.
450      */
451     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
452     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
453     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
454     ASSERT_NE(frameNode, nullptr);
455     frameNode->MarkModifyDone();
456     auto columnNode = AceType::DynamicCast<FrameNode>(frameNode->GetLastChild()->GetLastChild()->GetLastChild());
457     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
458     ASSERT_NE(pickerProperty, nullptr);
459     auto layoutWrapper =
460         AceType::MakeRefPtr<LayoutWrapperNode>(columnNode, columnNode->GetGeometryNode(), pickerProperty);
461     DirtySwapConfig dirtySwapConfig;
462     dirtySwapConfig.frameSizeChange = true;
463     auto pickerPattern = frameNode->GetPattern<TextPickerPattern>();
464     /**
465      * @tc.step: step2. call pattern's OnDirtyLayoutWrapperSwap method.
466      */
467     auto ret = pickerPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, dirtySwapConfig);
468     EXPECT_TRUE(ret);
469 }
470 
471 /**
472  * @tc.name: TextPickerPatternTest004
473  * @tc.desc: Test OnColumnsBuilding.
474  * @tc.type: FUNC
475  */
476 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest004, TestSize.Level1)
477 {
478     /**
479      * @tc.step: step1. create textpicker pattern.
480      */
481     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
482     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
483 
484     TextPickerModelNG::GetInstance()->SetIsCascade(true);
485     std::vector<NG::TextCascadePickerOptions> options;
486     NG::TextCascadePickerOptions options1;
487     options1.rangeResult = { "11", "12", "13" };
488     options.emplace_back(options1);
489     NG::TextCascadePickerOptions options2;
490     options2.rangeResult = { "21", "22", "23" };
491     options.emplace_back(options2);
492     NG::TextCascadePickerOptions options3;
493     options3.rangeResult = { "31", "32", "33" };
494     options.emplace_back(options3);
495     /**
496      * @tc.step: step2. Set Multi Columns and compare the result.
497      * @tc.expected: the result of SetColumns is correct.
498      */
499     TextPickerModelNG::GetInstance()->SetColumns(options);
500 
501     std::vector<uint32_t> selecteds = { 0, 1, 2 };
502     TextPickerModelNG::GetInstance()->SetSelecteds(selecteds);
503     TextPickerModelNG::GetInstance()->SetCanLoop(true);
504 
505     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
506     ASSERT_NE(frameNode, nullptr);
507 
508     auto pickerPattern = frameNode->GetPattern<TextPickerPattern>();
509     ASSERT_NE(pickerPattern, nullptr);
510     /**
511      * cover isCascade_ == true
512      */
513     pickerPattern->OnModifyDone();
514     /**
515      * cover isCascade_ == false
516      */
517     TextPickerModelNG::GetInstance()->SetIsCascade(false);
518     pickerPattern->SetCascadeOptions(options, options);
519     pickerPattern->OnModifyDone();
520 }
521 
522 /**
523  * @tc.name: TextPickerPatternTest005
524  * @tc.desc: Test GetSelectedObject
525  * @tc.type: FUNC
526  */
527 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest005, TestSize.Level1)
528 {
529     /**
530      * @tc.step: step1. create textpicker pattern.
531      */
532     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
533     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
534     auto frameNode =ViewStackProcessor::GetInstance()->GetMainFrameNode();
535     ASSERT_NE(frameNode, nullptr);
536     auto pickerPattern = frameNode->GetPattern<TextPickerPattern>();
537     ASSERT_NE(pickerPattern, nullptr);
538     TextPickerModelNG::GetInstance()->SetIsCascade(true);
539     std::vector<NG::TextCascadePickerOptions> options;
540     NG::TextCascadePickerOptions options1;
541     options1.rangeResult = { "11", "12", "13" };
542     options.emplace_back(options1);
543     NG::TextCascadePickerOptions options2;
544     options2.rangeResult = { "21", "22", "23" };
545     options.emplace_back(options2);
546     NG::TextCascadePickerOptions options3;
547     options3.rangeResult = { "31", "32", "33" };
548     options.emplace_back(options3);
549 
550     TextPickerModelNG::GetInstance()->SetColumns(options);
551     pickerPattern->SetCascadeOptions(options, options);
552     std::vector<uint32_t> selecteds = { 0, 1, 2 };
553     TextPickerModelNG::GetInstance()->SetSelecteds(selecteds);
554     std::vector<std::string> values = { "0", "1", "2" };
555     TextPickerModelNG::GetInstance()->SetValues(values);
556     TextPickerModelNG::GetInstance()->SetCanLoop(true);
557     frameNode->MarkModifyDone();
558     auto columnNode = AceType::DynamicCast<FrameNode>(frameNode->GetLastChild()->GetLastChild()->GetLastChild());
559     ASSERT_NE(columnNode, nullptr);
560     auto columnPattern = AceType::DynamicCast<FrameNode>(columnNode)->GetPattern<TextPickerColumnPattern>();
561     ASSERT_NE(columnPattern, nullptr);
562     /**
563      * test method HandleChangeCallback
564      */
565     columnPattern->HandleChangeCallback(true, true);
566 }
567 
568 /**
569  * @tc.name: TextPickerPatternTest006
570  * @tc.desc: Test TextPickerPattern SetButtonIdeaSize.
571  * @tc.type: FUNC
572  */
573 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest006, TestSize.Level1)
574 {
575     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::TEXT_PICKER_ETS_TAG,
__anonf1547e160a02() 576         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<TextPickerPattern>(); });
577     ASSERT_NE(frameNode, nullptr);
578     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
579     ASSERT_NE(textPickerPattern, nullptr);
580     auto buttonNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anonf1547e160b02() 581         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
582     auto columnNode =
583         FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e160c02() 584             []() { return AceType::MakeRefPtr<TextPickerColumnPattern>(); });
585     auto blendNode =
586         FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e160d02() 587             []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
588     auto layoutProperty = buttonNode->GetLayoutProperty<ButtonLayoutProperty>();
589     ASSERT_NE(layoutProperty, nullptr);
590     auto stackNode = FrameNode::GetOrCreateFrameNode(V2::STACK_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e160e02() 591         []() { return AceType::MakeRefPtr<StackPattern>(); });
592     auto geometryNode = stackNode->GetGeometryNode();
593     ASSERT_NE(geometryNode, nullptr);
594     buttonNode->MountToParent(stackNode);
595     columnNode->MountToParent(blendNode);
596     blendNode->MountToParent(stackNode);
597     stackNode->MountToParent(frameNode);
598     SizeF frameSize(FONT_SIZE_20, FONT_SIZE_20);
599     geometryNode->SetFrameSize(frameSize);
600     textPickerPattern->SetButtonIdeaSize();
601     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->width_.value(), CalcLength(12.0));
602 }
603 
604 /**
605  * @tc.name: TextPickerPatternTest007
606  * @tc.desc: Test TextPickerPattern CalculateHeight().
607  * @tc.type: FUNC
608  */
609 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest007, TestSize.Level1)
610 {
611     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::TEXT_PICKER_ETS_TAG,
__anonf1547e160f02() 612         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<TextPickerPattern>(); });
613     ASSERT_NE(frameNode, nullptr);
614     auto textPickerLayoutProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
615     ASSERT_NE(textPickerLayoutProperty, nullptr);
616     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
617     ASSERT_NE(textPickerPattern, nullptr);
618 
619     /**
620      * @tc.cases: case. cover branch HasDefaultPickerItemHeight() is true and DimensionUnit is PERCENT
621      */
622     Dimension dimension(10.0f);
623     dimension.SetUnit(DimensionUnit::PERCENT);
624     textPickerLayoutProperty->UpdateDefaultPickerItemHeight(dimension);
625     textPickerPattern->CalculateHeight();
626     EXPECT_EQ(textPickerLayoutProperty->GetDefaultPickerItemHeight(), dimension);
627 
628     /**
629      * @tc.cases: case. cover branch NormalizeToPx(defaultPickerItemHeightValue) less or equals 0.
630      */
631     Dimension dimension1(-10.0f);
632     textPickerLayoutProperty->UpdateDefaultPickerItemHeight(dimension1);
633     textPickerPattern->CalculateHeight();
634     EXPECT_EQ(textPickerLayoutProperty->GetDefaultPickerItemHeight(), dimension1);
635 
636     /**
637      * @tc.cases: case. cover branch NormalizeToPx(defaultPickerItemHeightValue) more than 0
638      */
639     Dimension dimension2(10.0f);
640     textPickerLayoutProperty->UpdateDefaultPickerItemHeight(dimension2);
641     textPickerPattern->CalculateHeight();
642     EXPECT_EQ(textPickerLayoutProperty->GetDefaultPickerItemHeight(), dimension2);
643 }
644 
645 /**
646  * @tc.name: TextPickerPatternTest008
647  * @tc.desc: Test TextPickerPattern HandleDirectionKey().
648  * @tc.type: FUNC
649  */
650 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest008, TestSize.Level1)
651 {
652     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
653     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
654     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
655     ASSERT_NE(frameNode, nullptr);
656     frameNode->MarkModifyDone();
657     auto columnNode = AceType::DynamicCast<FrameNode>(frameNode->GetLastChild()->GetLastChild()->GetLastChild());
658     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
659     ASSERT_NE(pickerProperty, nullptr);
660     auto layoutWrapper =
661         AceType::MakeRefPtr<LayoutWrapperNode>(columnNode, columnNode->GetGeometryNode(), pickerProperty);
662 
663     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
664 
665     /**
666      * @tc.cases: case1. KeyCode : KEY_DPAD_UP.
667      */
668     bool ret = textPickerPattern->HandleDirectionKey(KeyCode::KEY_DPAD_UP);
669     EXPECT_FALSE(ret);
670 
671     /**
672      * @tc.cases: case2. KeyCode : KEY_DPAD_DOWN.
673      */
674     bool retOne = textPickerPattern->HandleDirectionKey(KeyCode::KEY_DPAD_DOWN);
675     EXPECT_FALSE(retOne);
676 
677     /**
678      * @tc.cases: case3. KeyCode : KEY_ENTER.
679      */
680     bool retTwo = textPickerPattern->HandleDirectionKey(KeyCode::KEY_ENTER);
681     EXPECT_FALSE(retTwo);
682 
683     /**
684      * @tc.cases: case4. KeyCode : KEY_DPAD_LEFT.
685      */
686     bool retThree = textPickerPattern->HandleDirectionKey(KeyCode::KEY_DPAD_LEFT);
687     EXPECT_FALSE(retThree);
688 
689     /**
690      * @tc.cases: case5. KeyCode : KEY_DPAD_RIGHT.
691      */
692     bool retFour = textPickerPattern->HandleDirectionKey(KeyCode::KEY_DPAD_RIGHT);
693     EXPECT_FALSE(retFour);
694 }
695 
696 /**
697  * @tc.name: TextPickerPatternTest009
698  * @tc.desc: Test TextPickerPattern OnColorConfigurationUpdate().
699  * @tc.type: FUNC
700  */
701 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest009, TestSize.Level1)
702 {
703     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
704     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
705     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
706     ASSERT_NE(frameNode, nullptr);
707     frameNode->MarkModifyDone();
708     auto columnNode = AceType::DynamicCast<FrameNode>(frameNode->GetLastChild()->GetLastChild()->GetLastChild());
709     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
710     ASSERT_NE(pickerProperty, nullptr);
711     pickerProperty->contentConstraint_ = pickerProperty->CreateContentConstraint();
712 
713     /**
714      * @tc.cases: case. cover branch dialogTheme pass non null check .
715      */
716     auto pickerPattern = frameNode->GetPattern<TextPickerPattern>();
717 
718     /**
719      * @tc.cases: case. cover branch OnColorConfigurationUpdate isPicker_ == true.
720      */
721     pickerPattern->OnColorConfigurationUpdate();
722 }
723 
724 /**
725  * @tc.name: TextPickerPatternTest010
726  * @tc.desc: Test TextPickerPattern OnColorConfigurationUpdate().
727  * @tc.type: FUNC
728  */
729 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest010, TestSize.Level1)
730 {
731     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
732     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
733     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
734     ASSERT_NE(frameNode, nullptr);
735     frameNode->MarkModifyDone();
736     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
737     ASSERT_NE(pickerProperty, nullptr);
738     pickerProperty->contentConstraint_ = pickerProperty->CreateContentConstraint();
739 
740     /**
741      * @tc.cases: case. cover branch dialogTheme pass non null check .
742      */
743     auto pickerPattern = frameNode->GetPattern<TextPickerPattern>();
744 
745     /**
746      * @tc.cases: case. cover branch isPicker_ == false.
747      */
748     pickerPattern->SetPickerTag(false);
749     pickerPattern->OnColorConfigurationUpdate();
750 }
751 
752 /**
753  * @tc.name: TextPickerPatternTest011
754  * @tc.desc: Test TextPickerPattern OnColorConfigurationUpdate().
755  * @tc.type: FUNC
756  */
757 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest011, TestSize.Level1)
758 {
759     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
760     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
761     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
762     ASSERT_NE(frameNode, nullptr);
763     frameNode->MarkModifyDone();
764     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
765     ASSERT_NE(pickerProperty, nullptr);
766     pickerProperty->contentConstraint_ = pickerProperty->CreateContentConstraint();
767 
768     /**
769      * @tc.cases: case. cover branch dialogTheme pass non null check .
770      */
771     auto pickerPattern = frameNode->GetPattern<TextPickerPattern>();
772 
773     /**
774      * @tc.cases: case. cover branch isPicker_ == false.
775      */
776     pickerPattern->SetPickerTag(false);
777 
778     /**
779      * @tc.cases: case. cover branch contentRowNode_ is not null.
780      */
781     auto columnNode = pickerPattern->GetColumnNode();
782     pickerPattern->SetContentRowNode(columnNode);
783     pickerPattern->OnColorConfigurationUpdate();
784 }
785 
786 /**
787  * @tc.name: TextPickerPatternTest012
788  * @tc.desc: Test TextPickerPattern SetButtonIdeaSize.
789  * @tc.type: FUNC
790  */
791 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest012, TestSize.Level1)
792 {
793     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::TEXT_PICKER_ETS_TAG,
__anonf1547e161002() 794         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<TextPickerPattern>(); });
795     ASSERT_NE(frameNode, nullptr);
796     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
797     ASSERT_NE(textPickerPattern, nullptr);
798 
799     /**
800      * @tc.cases: case. cover branch resizeFlag_ == true.
801      */
802     textPickerPattern->SetResizeFlag(true);
803     auto buttonNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anonf1547e161102() 804         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
805     auto columnNode =
806         FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161202() 807             []() { return AceType::MakeRefPtr<TextPickerColumnPattern>(); });
808     auto blendNode =
809         FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161302() 810             []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
811     auto layoutProperty = buttonNode->GetLayoutProperty<ButtonLayoutProperty>();
812     ASSERT_NE(layoutProperty, nullptr);
813     auto stackNode = FrameNode::GetOrCreateFrameNode(V2::STACK_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161402() 814         []() { return AceType::MakeRefPtr<StackPattern>(); });
815     auto geometryNode = stackNode->GetGeometryNode();
816     ASSERT_NE(geometryNode, nullptr);
817     buttonNode->MountToParent(stackNode);
818     columnNode->MountToParent(blendNode);
819     blendNode->MountToParent(stackNode);
820     stackNode->MountToParent(frameNode);
821     SizeF frameSize(FONT_SIZE_20, FONT_SIZE_20);
822     geometryNode->SetFrameSize(frameSize);
823     textPickerPattern->SetButtonIdeaSize();
824     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->width_.value(), CalcLength(12.0));
825 }
826 
827 /**
828  * @tc.name: TextPickerPatternTest013
829  * @tc.desc: Test TextPickerPattern HandleDirectionKey().
830  * @tc.type: FUNC
831  */
832 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest013, TestSize.Level1)
833 {
834     /**
835      * @tc.step: step1. create textpicker pattern.
836      */
837     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
838     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
839     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
840     ASSERT_NE(frameNode, nullptr);
841     frameNode->MarkModifyDone();
842     auto columnNode = AceType::DynamicCast<FrameNode>(frameNode->GetLastChild()->GetLastChild()->GetLastChild());
843     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
844     ASSERT_NE(pickerProperty, nullptr);
845     auto layoutWrapper =
846         AceType::MakeRefPtr<LayoutWrapperNode>(columnNode, columnNode->GetGeometryNode(), pickerProperty);
847 
848     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
849 
850     /**
851      * @tc.step: step2. ccover branch totalOptionCount == 0.
852      * @tc.expected: call HandleDirectionKey() and result is false.
853      */
854     bool ret = textPickerPattern->HandleDirectionKey(KeyCode::KEY_DPAD_UP);
855     EXPECT_FALSE(ret);
856 }
857 
858 /**
859  * @tc.name: TextPickerPatternTest014
860  * @tc.desc: Test TextPickerPattern HandleDirectionKey.
861  * @tc.type: FUNC
862  */
863 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest014, TestSize.Level1)
864 {
865     /**
866      * @tc.step: step1. create textpicker pattern.
867      */
868     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
869     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
870     auto frameNode = AceType::Claim(ViewStackProcessor::GetInstance()->GetMainFrameNode());
871     ASSERT_NE(frameNode, nullptr);
872     frameNode->MarkModifyDone();
873     auto columnNode = AceType::DynamicCast<FrameNode>(frameNode->GetLastChild()->GetLastChild()->GetLastChild());
874     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
875     ASSERT_NE(pickerProperty, nullptr);
876     auto layoutWrapper =
877         AceType::MakeRefPtr<LayoutWrapperNode>(columnNode, columnNode->GetGeometryNode(), pickerProperty);
878     auto buttonNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anonf1547e161502() 879         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
880     auto blendNode =
881         FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161602() 882             []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
883     auto stackNode = FrameNode::GetOrCreateFrameNode(V2::STACK_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161702() 884         []() { return AceType::MakeRefPtr<StackPattern>(); });
885     auto geometryNode = stackNode->GetGeometryNode();
886     ASSERT_NE(geometryNode, nullptr);
887     buttonNode->MountToParent(stackNode);
888     columnNode->MountToParent(blendNode);
889     blendNode->MountToParent(stackNode);
890     stackNode->MountToParent(frameNode);
891 
892     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
893     auto pickerColumnPattern = columnNode->GetPattern<TextPickerColumnPattern>();
894     std::vector<RangeContent> options { { "icon" } };
895     pickerColumnPattern->SetOptions(options);
896 
897     /**
898      * @tc.cases: case. cover branch childSize more than 0.
899      */
900     bool ret = textPickerPattern->HandleDirectionKey(KeyCode::KEY_DPAD_RIGHT);
901     EXPECT_TRUE(ret);
902 
903     /**
904      * @tc.cases: case. cover branch code default branch.
905      */
906     bool ret1 = textPickerPattern->HandleDirectionKey(KeyCode::KEY_DPAD_CENTER);
907     EXPECT_FALSE(ret1);
908 }
909 
910 /**
911  * @tc.name: TextPickerPatternTest015
912  * @tc.desc: Test TextPickerPattern GetSelectedObjectMulti.
913  * @tc.type: FUNC
914  */
915 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest015, TestSize.Level1)
916 {
917     /**
918      * @tc.step: step1. create textpicker pattern.
919      */
920     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
921     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
922     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
923     ASSERT_NE(frameNode, nullptr);
924     frameNode->MarkModifyDone();
925     auto columnNode = AceType::DynamicCast<FrameNode>(frameNode->GetLastChild()->GetLastChild()->GetLastChild());
926     auto pickerProperty = frameNode->GetLayoutProperty<TextPickerLayoutProperty>();
927     ASSERT_NE(pickerProperty, nullptr);
928     auto layoutWrapper =
929         AceType::MakeRefPtr<LayoutWrapperNode>(columnNode, columnNode->GetGeometryNode(), pickerProperty);
930 
931     /**
932      * @tc.step: step2. Construction parameters and call GetSelectedObjectMulti().
933      * @tc.expected: result is expected.
934      */
935     std::vector<std::string> values = { "111", "123", "134" };
936     const std::vector<uint32_t> indexs = { 0, 1, 2 };
937     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
938     std::string result = textPickerPattern->GetSelectedObjectMulti(values, indexs, 2);
939     std::string expectResult = "{\"value\":[\"111\",\"123\",\"134\"],\"index\":[0,1,2],\"status\":2}";
940     EXPECT_EQ(result, expectResult);
941 }
942 
943 /**
944  * @tc.name: TextPickerPatternTest016
945  * @tc.desc: Test ChangeCurrentOptionValue
946  * @tc.type: FUNC
947  */
948 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest016, TestSize.Level1)
949 {
950     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
951 
952     /**
953      * @tc.step: step1. create textpicker pattern.
954      */
955     TextPickerModelNG::GetInstance()->Create(theme, TEXT);
956     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
957     ASSERT_NE(frameNode, nullptr);
958     auto pickerPattern = frameNode->GetPattern<TextPickerPattern>();
959     ASSERT_NE(pickerPattern, nullptr);
960 
961     /**
962      * @tc.step: step2. Initialize TextCascadePickerOptions、selecteds_ and values.
963      */
964     TextPickerModelNG::GetInstance()->SetIsCascade(true);
965     std::vector<NG::TextCascadePickerOptions> options;
966     NG::TextCascadePickerOptions option;
967     option.rangeResult = { "111", "123", "134" };
968     NG::TextCascadePickerOptions optionsChild1;
969     optionsChild1.rangeResult = { "11", "12", "13" };
970     options.emplace_back(optionsChild1);
971     NG::TextCascadePickerOptions optionsChild2;
972     optionsChild2.rangeResult = { "21", "22", "23" };
973     options.emplace_back(optionsChild2);
974     option.children = options;
975 
976     pickerPattern->selecteds_ = { 0, 0 };
977     std::vector<std::string> values;
978     values.emplace_back("1");
979     values.emplace_back("2");
980     pickerPattern->SetValues(values);
981 
982     /**
983      * @tc.step: step3. call ChangeCurrentOptionValue(), cover branch replaceColumn less or equals curColumn.
984      * @tc.expected: expect successfully.
985      */
986     pickerPattern->ChangeCurrentOptionValue(optionsChild1, 16, 1, 0);
987     EXPECT_EQ(pickerPattern->selecteds_[1], 16);
988 
989     /**
990      * @tc.cases: case. cover branch replaceColumn more than curColumn.
991      */
992     pickerPattern->ChangeCurrentOptionValue(option, 17, 0, 1);
993     EXPECT_EQ(pickerPattern->selecteds_[1], 17);
994 }
995 
996 /**
997  * @tc.name: TextPickerPatternTest017
998  * @tc.desc: Test OnLanguageConfigurationUpdate.
999  * @tc.type: FUNC
1000  */
1001 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternTest017, TestSize.Level1)
1002 {
1003     const std::string language = "en";
1004     const std::string countryOrRegion = "US";
1005     const std::string script = "Latn";
1006     const std::string keywordsAndValues = "";
1007     auto contentColumn = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
1008         AceType::MakeRefPtr<LinearLayoutPattern>(true));
1009     auto textPickerNode = FrameNode::GetOrCreateFrameNode(
__anonf1547e161802() 1010         V2::TEXT_PICKER_ETS_TAG, 1, []() { return AceType::MakeRefPtr<TextPickerPattern>(); });
1011     auto textPickerPattern = textPickerNode->GetPattern<TextPickerPattern>();
1012     textPickerNode->MountToParent(contentColumn);
1013     auto buttonConfirmNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anonf1547e161902() 1014         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<NG::ButtonPattern>(); });
1015     auto textConfirmNode = FrameNode::CreateFrameNode(
1016         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
1017     CHECK_NULL_VOID(buttonConfirmNode);
1018     CHECK_NULL_VOID(textConfirmNode);
1019     textConfirmNode->MountToParent(buttonConfirmNode);
1020     textPickerPattern->SetConfirmNode(buttonConfirmNode);
1021     auto buttonCancelNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anonf1547e161a02() 1022         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1023     CHECK_NULL_VOID(buttonCancelNode);
1024     auto textCancelNode = FrameNode::CreateFrameNode(
1025         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
1026     CHECK_NULL_VOID(textCancelNode);
1027     textCancelNode->MountToParent(buttonCancelNode);
1028     textPickerPattern->SetCancelNode(buttonCancelNode);
1029     textPickerPattern->OnLanguageConfigurationUpdate();
1030     AceApplicationInfo::GetInstance().SetLocale(language, countryOrRegion, script, keywordsAndValues);
1031     std::string nodeInfo = "";
1032     auto cancel = Localization::GetInstance()->GetEntryLetters("common.cancel");
1033     EXPECT_EQ(cancel, nodeInfo);
1034 }
1035 
1036 /**
1037  * @tc.name: TextPickerColumnPatternOnClickEventTest001
1038  * @tc.desc: test OnTouchEvent
1039  * @tc.type: FUNC
1040  */
1041 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest001, TestSize.Level1)
1042 {
1043     InitTextPickerPatternTestNg();
1044     textPickerColumnPattern_->InitMouseAndPressEvent();
1045     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1046     textPickerColumnPattern_->SetOptions(range);
1047     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1048     theme->showOptionCount_ = 5;
1049 
1050     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1051     pickerNodeLayout->UpdateCanLoop(true);
1052     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1053     uint32_t index = 0;
1054 
1055     // current is 0, click up
1056     textPickerColumnPattern_->SetCurrentIndex(0);
1057     param->instance = nullptr;
1058     param->itemIndex = 1;
1059     param->itemTotalCounts = 5;
1060     TextPickerOptionProperty prop;
1061     prop.height = 4.0f;
1062     prop.fontheight = 3.0f;
1063     prop.prevDistance = 5.0f;
1064     prop.nextDistance = 7.0f;
1065     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1066     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1067     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1068     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1069     textPickerColumnPattern_->OnAroundButtonClick(param);
1070     index = textPickerColumnPattern_->GetCurrentIndex();
1071     EXPECT_EQ(index, 0);
1072 }
1073 
1074 /**
1075  * @tc.name: TextPickerColumnPatternOnClickEventTest002
1076  * @tc.desc: test OnTouchEvent
1077  * @tc.type: FUNC
1078  */
1079 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest002, TestSize.Level1)
1080 {
1081     InitTextPickerPatternTestNg();
1082     textPickerColumnPattern_->InitMouseAndPressEvent();
1083     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1084     textPickerColumnPattern_->SetOptions(range);
1085     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1086     theme->showOptionCount_ = 5;
1087 
1088     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1089     pickerNodeLayout->UpdateCanLoop(true);
1090     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1091     uint32_t index = 0;
1092 
1093     // current is 0, click up
1094     textPickerColumnPattern_->SetCurrentIndex(0);
1095     param->instance = nullptr;
1096     param->itemIndex = 0;
1097     param->itemTotalCounts = 5;
1098     TextPickerOptionProperty prop;
1099     prop.height = 4.0f;
1100     prop.fontheight = 3.0f;
1101     prop.prevDistance = 5.0f;
1102     prop.nextDistance = 7.0f;
1103     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1104     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1105     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1106     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1107     textPickerColumnPattern_->OnAroundButtonClick(param);
1108     index = textPickerColumnPattern_->GetCurrentIndex();
1109     EXPECT_EQ(index, 0);
1110 }
1111 
1112 /**
1113  * @tc.name: TextPickerColumnPatternOnClickEventTest003
1114  * @tc.desc: test OnTouchEvent
1115  * @tc.type: FUNC
1116  */
1117 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest003, TestSize.Level1)
1118 {
1119     InitTextPickerPatternTestNg();
1120     textPickerColumnPattern_->InitMouseAndPressEvent();
1121     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1122     textPickerColumnPattern_->SetOptions(range);
1123     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1124     theme->showOptionCount_ = 5;
1125 
1126     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1127     pickerNodeLayout->UpdateCanLoop(true);
1128     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1129     uint32_t index = 0;
1130 
1131     // current is 0, click down
1132     textPickerColumnPattern_->SetCurrentIndex(0);
1133     param->instance = nullptr;
1134     param->itemIndex = 3;
1135     param->itemTotalCounts = 5;
1136     TextPickerOptionProperty prop;
1137     prop.height = 4.0f;
1138     prop.fontheight = 3.0f;
1139     prop.prevDistance = 5.0f;
1140     prop.nextDistance = 7.0f;
1141     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1142     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1143     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1144     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1145     textPickerColumnPattern_->OnAroundButtonClick(param);
1146     index = textPickerColumnPattern_->GetCurrentIndex();
1147     EXPECT_EQ(index, 0);
1148 }
1149 
1150 /**
1151  * @tc.name: TextPickerColumnPatternOnClickEventTest004
1152  * @tc.desc: test OnTouchEvent
1153  * @tc.type: FUNC
1154  */
1155 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest004, TestSize.Level1)
1156 {
1157     InitTextPickerPatternTestNg();
1158     textPickerColumnPattern_->InitMouseAndPressEvent();
1159     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1160     textPickerColumnPattern_->SetOptions(range);
1161     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1162     theme->showOptionCount_ = 5;
1163 
1164     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1165     pickerNodeLayout->UpdateCanLoop(true);
1166     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1167     uint32_t index = 0;
1168 
1169     // current is 0, click down
1170     textPickerColumnPattern_->SetCurrentIndex(0);
1171     param->instance = nullptr;
1172     param->itemIndex = 4;
1173     param->itemTotalCounts = 5;
1174     TextPickerOptionProperty prop;
1175     prop.height = 4.0f;
1176     prop.fontheight = 3.0f;
1177     prop.prevDistance = 5.0f;
1178     prop.nextDistance = 7.0f;
1179     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1180     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1181     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1182     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1183     textPickerColumnPattern_->OnAroundButtonClick(param);
1184     index = textPickerColumnPattern_->GetCurrentIndex();
1185     EXPECT_EQ(index, 0);
1186 }
1187 
1188 /**
1189  * @tc.name: TextPickerColumnPatternOnClickEventTest005
1190  * @tc.desc: test OnTouchEvent
1191  * @tc.type: FUNC
1192  */
1193 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest005, TestSize.Level1)
1194 {
1195     InitTextPickerPatternTestNg();
1196     textPickerColumnPattern_->InitMouseAndPressEvent();
1197     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1198     textPickerColumnPattern_->SetOptions(range);
1199     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1200     theme->showOptionCount_ = 5;
1201 
1202     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1203     pickerNodeLayout->UpdateCanLoop(true);
1204     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1205     uint32_t index = 0;
1206 
1207     // current is 2, click up
1208     textPickerColumnPattern_->SetCurrentIndex(2);
1209     param->instance = nullptr;
1210     param->itemIndex = 1;
1211     param->itemTotalCounts = 5;
1212     TextPickerOptionProperty prop;
1213     prop.height = 4.0f;
1214     prop.fontheight = 3.0f;
1215     prop.prevDistance = 5.0f;
1216     prop.nextDistance = 7.0f;
1217     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1218     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1219     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1220     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1221     textPickerColumnPattern_->OnAroundButtonClick(param);
1222     index = textPickerColumnPattern_->GetCurrentIndex();
1223     EXPECT_EQ(index, 2);
1224 }
1225 
1226 /**
1227  * @tc.name: TextPickerColumnPatternOnClickEventTest006
1228  * @tc.desc: test OnTouchEvent
1229  * @tc.type: FUNC
1230  */
1231 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest006, TestSize.Level1)
1232 {
1233     InitTextPickerPatternTestNg();
1234     textPickerColumnPattern_->InitMouseAndPressEvent();
1235     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1236     textPickerColumnPattern_->SetOptions(range);
1237     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1238     theme->showOptionCount_ = 5;
1239 
1240     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1241     pickerNodeLayout->UpdateCanLoop(true);
1242     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1243     uint32_t index = 0;
1244 
1245     // current is 2, click up
1246     textPickerColumnPattern_->SetCurrentIndex(2);
1247     param->instance = nullptr;
1248     param->itemIndex = 0;
1249     param->itemTotalCounts = 5;
1250     TextPickerOptionProperty prop;
1251     prop.height = 4.0f;
1252     prop.fontheight = 3.0f;
1253     prop.prevDistance = 5.0f;
1254     prop.nextDistance = 7.0f;
1255     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1256     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1257     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1258     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1259     textPickerColumnPattern_->OnAroundButtonClick(param);
1260     index = textPickerColumnPattern_->GetCurrentIndex();
1261     EXPECT_EQ(index, 2);
1262 }
1263 
1264 /**
1265  * @tc.name: TextPickerColumnPatternOnClickEventTest007
1266  * @tc.desc: test OnTouchEvent
1267  * @tc.type: FUNC
1268  */
1269 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest007, TestSize.Level1)
1270 {
1271     InitTextPickerPatternTestNg();
1272     textPickerColumnPattern_->InitMouseAndPressEvent();
1273     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1274     textPickerColumnPattern_->SetOptions(range);
1275     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1276     theme->showOptionCount_ = 5;
1277 
1278     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1279     pickerNodeLayout->UpdateCanLoop(true);
1280     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1281     uint32_t index = 0;
1282 
1283     // current is 2, click down
1284     textPickerColumnPattern_->SetCurrentIndex(2);
1285     param->instance = nullptr;
1286     param->itemIndex = 3;
1287     param->itemTotalCounts = 5;
1288     TextPickerOptionProperty prop;
1289     prop.height = 4.0f;
1290     prop.fontheight = 3.0f;
1291     prop.prevDistance = 5.0f;
1292     prop.nextDistance = 7.0f;
1293     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1294     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1295     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1296     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1297     textPickerColumnPattern_->OnAroundButtonClick(param);
1298     index = textPickerColumnPattern_->GetCurrentIndex();
1299     EXPECT_EQ(index, 2);
1300 }
1301 
1302 /**
1303  * @tc.name: TextPickerColumnPatternOnClickEventTest008
1304  * @tc.desc: test OnTouchEvent
1305  * @tc.type: FUNC
1306  */
1307 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest008, TestSize.Level1)
1308 {
1309     InitTextPickerPatternTestNg();
1310     textPickerColumnPattern_->InitMouseAndPressEvent();
1311     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1312     textPickerColumnPattern_->SetOptions(range);
1313     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1314     theme->showOptionCount_ = 5;
1315 
1316     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1317     pickerNodeLayout->UpdateCanLoop(true);
1318     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1319     uint32_t index = 0;
1320 
1321     // current is 2, click down
1322     textPickerColumnPattern_->SetCurrentIndex(2);
1323     param->instance = nullptr;
1324     param->itemIndex = 4;
1325     param->itemTotalCounts = 5;
1326     TextPickerOptionProperty prop;
1327     prop.height = 4.0f;
1328     prop.fontheight = 3.0f;
1329     prop.prevDistance = 5.0f;
1330     prop.nextDistance = 7.0f;
1331     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1332     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1333     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1334     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1335     textPickerColumnPattern_->OnAroundButtonClick(param);
1336     index = textPickerColumnPattern_->GetCurrentIndex();
1337     EXPECT_EQ(index, 2);
1338 }
1339 
1340 /**
1341  * @tc.name: TextPickerColumnPatternOnClickEventTest009
1342  * @tc.desc: test OnTouchEvent
1343  * @tc.type: FUNC
1344  */
1345 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest009, TestSize.Level1)
1346 {
1347     InitTextPickerPatternTestNg();
1348     textPickerColumnPattern_->InitMouseAndPressEvent();
1349     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1350     textPickerColumnPattern_->SetOptions(range);
1351     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1352     theme->showOptionCount_ = 5;
1353 
1354     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1355     pickerNodeLayout->UpdateCanLoop(true);
1356     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1357     uint32_t index = 0;
1358 
1359     // current is 4, click up
1360     textPickerColumnPattern_->SetCurrentIndex(4);
1361     param->instance = nullptr;
1362     param->itemIndex = 1;
1363     param->itemTotalCounts = 5;
1364     TextPickerOptionProperty prop;
1365     prop.height = 4.0f;
1366     prop.fontheight = 3.0f;
1367     prop.prevDistance = 5.0f;
1368     prop.nextDistance = 7.0f;
1369     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1370     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1371     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1372     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1373     textPickerColumnPattern_->OnAroundButtonClick(param);
1374     index = textPickerColumnPattern_->GetCurrentIndex();
1375     EXPECT_EQ(index, 4);
1376 }
1377 
1378 /**
1379  * @tc.name: TextPickerColumnPatternOnClickEventTest010
1380  * @tc.desc: test OnTouchEvent
1381  * @tc.type: FUNC
1382  */
1383 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest010, TestSize.Level1)
1384 {
1385     InitTextPickerPatternTestNg();
1386     textPickerColumnPattern_->InitMouseAndPressEvent();
1387     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1388     textPickerColumnPattern_->SetOptions(range);
1389     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1390     theme->showOptionCount_ = 5;
1391 
1392     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1393     pickerNodeLayout->UpdateCanLoop(true);
1394     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1395     uint32_t index = 0;
1396 
1397     // current is 4, click up
1398     textPickerColumnPattern_->SetCurrentIndex(4);
1399     param->instance = nullptr;
1400     param->itemIndex = 0;
1401     param->itemTotalCounts = 5;
1402     TextPickerOptionProperty prop;
1403     prop.height = 4.0f;
1404     prop.fontheight = 3.0f;
1405     prop.prevDistance = 5.0f;
1406     prop.nextDistance = 7.0f;
1407     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1408     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1409     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1410     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1411     textPickerColumnPattern_->OnAroundButtonClick(param);
1412     index = textPickerColumnPattern_->GetCurrentIndex();
1413     EXPECT_EQ(index, 4);
1414 }
1415 
1416 /**
1417  * @tc.name: TextPickerColumnPatternOnClickEventTest011
1418  * @tc.desc: test OnTouchEvent
1419  * @tc.type: FUNC
1420  */
1421 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest011, TestSize.Level1)
1422 {
1423     InitTextPickerPatternTestNg();
1424     textPickerColumnPattern_->InitMouseAndPressEvent();
1425     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1426     textPickerColumnPattern_->SetOptions(range);
1427     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1428     theme->showOptionCount_ = 5;
1429 
1430     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1431     pickerNodeLayout->UpdateCanLoop(true);
1432     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1433     uint32_t index = 0;
1434 
1435     // current is 4, click down
1436     textPickerColumnPattern_->SetCurrentIndex(4);
1437     param->instance = nullptr;
1438     param->itemIndex = 3;
1439     param->itemTotalCounts = 5;
1440     TextPickerOptionProperty prop;
1441     prop.height = 4.0f;
1442     prop.fontheight = 3.0f;
1443     prop.prevDistance = 5.0f;
1444     prop.nextDistance = 7.0f;
1445     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1446     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1447     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1448     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1449     textPickerColumnPattern_->OnAroundButtonClick(param);
1450     index = textPickerColumnPattern_->GetCurrentIndex();
1451     EXPECT_EQ(index, 4);
1452 }
1453 
1454 /**
1455  * @tc.name: TextPickerColumnPatternOnClickEventTest012
1456  * @tc.desc: test OnTouchEvent
1457  * @tc.type: FUNC
1458  */
1459 HWTEST_F(TextPickerPatternTestNg, TextPickerColumnPatternOnClickEventTest012, TestSize.Level1)
1460 {
1461     InitTextPickerPatternTestNg();
1462     textPickerColumnPattern_->InitMouseAndPressEvent();
1463     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1464     textPickerColumnPattern_->SetOptions(range);
1465     auto theme = MockPipelineContext::GetCurrent()->GetTheme<PickerTheme>();
1466     theme->showOptionCount_ = 5;
1467 
1468     auto pickerNodeLayout = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1469     pickerNodeLayout->UpdateCanLoop(true);
1470     RefPtr<EventParam> param = AceType::MakeRefPtr<EventParam>();
1471     uint32_t index = 0;
1472 
1473     // current is 4, click down
1474     textPickerColumnPattern_->SetCurrentIndex(4);
1475     param->instance = nullptr;
1476     param->itemIndex = 4;
1477     param->itemTotalCounts = 5;
1478     TextPickerOptionProperty prop;
1479     prop.height = 4.0f;
1480     prop.fontheight = 3.0f;
1481     prop.prevDistance = 5.0f;
1482     prop.nextDistance = 7.0f;
1483     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1484     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1485     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1486     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1487     textPickerColumnPattern_->OnAroundButtonClick(param);
1488     index = textPickerColumnPattern_->GetCurrentIndex();
1489     EXPECT_EQ(index, 4);
1490 
1491     // color is set = Color::xxx
1492     param->instance = nullptr;
1493     param->itemIndex = 2;
1494     param->itemTotalCounts = 5;
1495     textPickerColumnPattern_->OnMiddleButtonTouchDown();
1496 
1497     // color is set = Color::TRANSPARENT
1498     param->instance = nullptr;
1499     param->itemIndex = 2;
1500     param->itemTotalCounts = 5;
1501     textPickerColumnPattern_->OnMiddleButtonTouchMove();
1502 
1503     // color is set = Color::TRANSPARENT
1504     param->instance = nullptr;
1505     param->itemIndex = 2;
1506     param->itemTotalCounts = 5;
1507     textPickerColumnPattern_->OnMiddleButtonTouchUp();
1508 
1509     textPickerColumnPattern_->HandleMouseEvent(false);
1510     textPickerColumnPattern_->HandleMouseEvent(true);
1511 }
1512 
1513 /**
1514  * @tc.name: TextPickerPatternHandleDirectionKey001
1515  * @tc.desc: Test HandleDirectionKey
1516  * @tc.type: FUNC
1517  */
1518 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternHandleDirectionKey001, TestSize.Level1)
1519 {
1520     InitTextPickerPatternTestNg();
1521     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1522     textPickerColumnPattern_->SetOptions(range);
1523     /**
1524      * @tc.cases: case. cover KeyCode == KEY_DPAD_UP.
1525      */
1526     EXPECT_TRUE(textPickerPattern_->HandleDirectionKey(KeyCode::KEY_DPAD_UP));
1527     /**
1528      * @tc.cases: case. cover KeyCode == KEY_DPAD_DOWN.
1529      */
1530     EXPECT_TRUE(textPickerPattern_->HandleDirectionKey(KeyCode::KEY_DPAD_DOWN));
1531     /**
1532      * @tc.cases: case. cover KeyCode == KEY_ENTER.
1533      */
1534     EXPECT_TRUE(textPickerPattern_->HandleDirectionKey(KeyCode::KEY_ENTER));
1535     /**
1536      * @tc.cases: case. cover KeyCode == KEY_DPAD_LEFT.
1537      */
1538     textPickerPattern_->focusKeyID_ = 0;
1539     EXPECT_TRUE(textPickerPattern_->HandleDirectionKey(KeyCode::KEY_DPAD_LEFT));
1540 }
1541 
1542 /**
1543  * @tc.name: TextPickerPatternHandleDirectionKey002
1544  * @tc.desc: Test HandleDirectionKey
1545  * @tc.type: FUNC
1546  */
1547 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternHandleDirectionKey002, TestSize.Level1)
1548 {
1549     /**
1550      * @tc.step: step1. create textpicker pattern.
1551      */
1552     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::TEXT_PICKER_ETS_TAG,
__anonf1547e161b02() 1553         ViewStackProcessor::GetInstance()->ClaimNodeId(), []() { return AceType::MakeRefPtr<TextPickerPattern>(); });
1554     ASSERT_NE(frameNode, nullptr);
1555     auto textPickerPattern = frameNode->GetPattern<TextPickerPattern>();
1556     ASSERT_NE(textPickerPattern, nullptr);
1557     auto stackNode1 = FrameNode::GetOrCreateFrameNode(V2::STACK_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161c02() 1558         []() { return AceType::MakeRefPtr<StackPattern>(); });
1559     ASSERT_NE(stackNode1, nullptr);
1560     auto stackNode2 = FrameNode::GetOrCreateFrameNode(V2::STACK_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161d02() 1561         []() { return AceType::MakeRefPtr<StackPattern>(); });
1562     ASSERT_NE(stackNode2, nullptr);
1563     auto blendNode1 = FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG,
1564         ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161e02() 1565         []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1566     ASSERT_NE(blendNode1, nullptr);
1567     auto blendNode2 = FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG,
1568         ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e161f02() 1569         []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1570     ASSERT_NE(blendNode2, nullptr);
1571     auto columnNode1 = FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG,
1572         ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e162002() 1573         []() { return AceType::MakeRefPtr<TextPickerColumnPattern>(); });
1574     ASSERT_NE(columnNode1, nullptr);
1575     auto columnNode2 = FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG,
1576         ElementRegister::GetInstance()->MakeUniqueId(),
__anonf1547e162102() 1577         []() { return AceType::MakeRefPtr<TextPickerColumnPattern>(); });
1578     ASSERT_NE(columnNode2, nullptr);
1579     columnNode1->MountToParent(blendNode1);
1580     blendNode1->MountToParent(stackNode1);
1581     stackNode1->MountToParent(frameNode);
1582     columnNode2->MountToParent(blendNode2);
1583     blendNode2->MountToParent(stackNode2);
1584     stackNode2->MountToParent(frameNode);
1585     auto textPickerColumnPattern2 = columnNode2->GetPattern<TextPickerColumnPattern>();
1586     ASSERT_NE(textPickerColumnPattern2, nullptr);
1587     /**
1588      * @tc.step: step2. SetOptions and call HandleDirectionKey.
1589      */
1590     std::vector<NG::RangeContent> range = { { "", "1" }, { "", "2" }, { "", "3" }, { "", "4" }, { "", "5" } };
1591     textPickerColumnPattern2->SetOptions(range);
1592     textPickerPattern->focusKeyID_ = 1;
1593     bool result = textPickerPattern->HandleDirectionKey(KeyCode::KEY_DPAD_LEFT);
1594     EXPECT_TRUE(result);
1595 }
1596 
1597 /**
1598  * @tc.name: TextPickerPatternPlayResetAnimation001
1599  * @tc.desc: Test PlayResetAnimation
1600  * @tc.type: FUNC
1601  */
1602 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternPlayResetAnimation001, TestSize.Level1)
1603 {
1604     InitTextPickerPatternTestNg();
1605     TextPickerOptionProperty prop;
1606     prop.height = 4.0f;
1607     prop.fontheight = 3.0f;
1608     prop.prevDistance = 5.0f;
1609     prop.nextDistance = 7.0f;
1610     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1611     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1612     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1613     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1614     /**
1615      * @tc.cases: case. cover isDownScroll_ == false
1616      */
1617     textPickerColumnPattern_->PlayResetAnimation();
1618     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 0.0f);
1619 
1620     textPickerColumnPattern_->scrollDelta_ = 10.0f;
1621     textPickerColumnPattern_->PlayResetAnimation();
1622     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 15.0f);
1623 }
1624 
1625 /**
1626  * @tc.name: TextPickerPatternPlayResetAnimation002
1627  * @tc.desc: Test PlayResetAnimation
1628  * @tc.type: FUNC
1629  */
1630 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternPlayResetAnimation002, TestSize.Level1)
1631 {
1632     InitTextPickerPatternTestNg();
1633     TextPickerOptionProperty prop;
1634     prop.height = 4.0f;
1635     prop.fontheight = 3.0f;
1636     prop.prevDistance = 5.0f;
1637     prop.nextDistance = 7.0f;
1638     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1639     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1640     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1641     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1642     /**
1643      * @tc.cases: case. cover isDownScroll_ == true
1644      */
1645     textPickerColumnPattern_->SetScrollDirection(true);
1646     textPickerColumnPattern_->PlayResetAnimation();
1647     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 0.0f);
1648 
1649     textPickerColumnPattern_->SetScrollDirection(true);
1650     textPickerColumnPattern_->scrollDelta_ = 10.0f;
1651     textPickerColumnPattern_->PlayResetAnimation();
1652     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 3.0f);
1653 }
1654 
1655 /**
1656  * @tc.name: TextPickerPatternUpdateColumnChildPosition001
1657  * @tc.desc: Test UpdateColumnChildPosition
1658  * @tc.type: FUNC
1659  */
1660 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternUpdateColumnChildPosition001, TestSize.Level1)
1661 {
1662     InitTextPickerPatternTestNg();
1663     TextPickerOptionProperty prop;
1664     prop.height = 4.0f;
1665     prop.fontheight = 3.0f;
1666     prop.prevDistance = 5.0f;
1667     prop.nextDistance = 7.0f;
1668     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1669     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1670     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1671     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1672     /**
1673      * @tc.cases: case. cover isReboundInProgress_ == true && canLoop_ == true
1674      */
1675     textPickerColumnPattern_->isReboundInProgress_ = true;
1676     textPickerColumnPattern_->SetYLast(1.0);
1677     textPickerColumnPattern_->UpdateColumnChildPosition(2.0);
1678     std::vector<NG::RangeContent> range = { { "", "" } };
1679     textPickerColumnPattern_->SetOptions(range);
1680     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 1.0f);
1681     /**
1682      * @tc.cases: case. cover isReboundInProgress_ == true && canLoop_ == false
1683      */
1684     auto property = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1685     ASSERT_NE(property, nullptr);
1686     property->UpdateCanLoop(false);
1687     textPickerColumnPattern_->isReboundInProgress_ = true;
1688     textPickerColumnPattern_->SetYLast(1.0);
1689     textPickerColumnPattern_->UpdateColumnChildPosition(2.0);
1690     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 2.0f);
1691     /**
1692      * @tc.cases: case. cover isReboundInProgress_ == false && canLoop_ == false
1693      */
1694     property->UpdateCanLoop(false);
1695     textPickerColumnPattern_->isReboundInProgress_ = false;
1696     textPickerColumnPattern_->SetYLast(1.0);
1697     textPickerColumnPattern_->UpdateColumnChildPosition(2.0);
1698     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 0.0f);
1699 }
1700 
1701 /**
1702  * @tc.name: TextPickerPatternUpdateColumnChildPosition002
1703  * @tc.desc: Test UpdateColumnChildPosition
1704  * @tc.type: FUNC
1705  */
1706 HWTEST_F(TextPickerPatternTestNg, TextPickerPatternUpdateColumnChildPosition002, TestSize.Level1)
1707 {
1708     InitTextPickerPatternTestNg();
1709     TextPickerOptionProperty prop;
1710     prop.height = 4.0f;
1711     prop.fontheight = 3.0f;
1712     prop.prevDistance = 5.0f;
1713     prop.nextDistance = 7.0f;
1714     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1715     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1716     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1717     textPickerColumnPattern_->optionProperties_.emplace_back(prop);
1718     std::vector<NG::RangeContent> range = { { "", "" } };
1719     textPickerColumnPattern_->SetOptions(range);
1720     /**
1721      * @tc.cases: case. covering the false branch
1722      */
1723     textPickerColumnPattern_->pressed_ = true;
1724     textPickerColumnPattern_->SetTossStatus(true);
1725     textPickerColumnPattern_->overscroller_.SetOverScroll(1.0);
1726     textPickerColumnPattern_->SetYLast(1.0);
1727     textPickerColumnPattern_->UpdateColumnChildPosition(2.0);
1728     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 1.0f);
1729     /**
1730      * @tc.cases: case. covering the true branch
1731      */
1732     auto property = frameNode_->GetLayoutProperty<TextPickerLayoutProperty>();
1733     ASSERT_NE(property, nullptr);
1734     property->UpdateCanLoop(false);
1735     textPickerColumnPattern_->pressed_ = false;
1736     textPickerColumnPattern_->SetTossStatus(true);
1737     textPickerColumnPattern_->overscroller_.SetOverScroll(10.0);
1738     textPickerColumnPattern_->SetYLast(1.0);
1739     textPickerColumnPattern_->UpdateColumnChildPosition(2.0);
1740     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 0.0f);
1741     /**
1742      * @tc.cases: case. covering the return branch
1743      */
1744     textPickerColumnPattern_->SetYLast(1.0);
1745     textPickerColumnPattern_->UpdateColumnChildPosition(1.0);
1746     EXPECT_EQ(textPickerColumnPattern_->scrollDelta_, 0.0f);
1747 }
1748 
1749 /**
1750  * @tc.name: LinearFontSize001
1751  * @tc.desc: TextPickerColumnPattern LinearFontSize
1752  * @tc.type: FUNC
1753  */
1754 HWTEST_F(TextPickerPatternTestNg, LinearFontSize001, TestSize.Level1)
1755 {
1756     InitTextPickerPatternTestNg();
1757     Dimension dimension = Dimension(FONT_SIZE_10);
1758     Dimension dimension1;
1759     dimension1 = textPickerColumnPattern_->LinearFontSize(dimension, dimension, 1);
1760     EXPECT_FALSE(dimension < dimension1);
1761 }
1762 
1763 /**
1764  * @tc.name: LinearFontSize002
1765  * @tc.desc: TextPickerColumnPattern LinearFontSize
1766  * @tc.type: FUNC
1767  */
1768 HWTEST_F(TextPickerPatternTestNg, LinearFontSize002, TestSize.Level1)
1769 {
1770     InitTextPickerPatternTestNg();
1771     Dimension dimension = Dimension(FONT_SIZE_10);
1772     Dimension dimension1;
1773     dimension1 = textPickerColumnPattern_->LinearFontSize(dimension, dimension, 2);
1774     EXPECT_FALSE(dimension < dimension1);
1775 }
1776 
1777 /**
1778  * @tc.name: GetOverScrollDeltaIndex001
1779  * @tc.desc: TextPickerColumnPattern GetOverScrollDeltaIndex
1780  * @tc.type: FUNC
1781  */
1782 HWTEST_F(TextPickerPatternTestNg, GetOverScrollDeltaIndex001, TestSize.Level1)
1783 {
1784     InitTextPickerPatternTestNg();
1785     int32_t index = textPickerColumnPattern_->GetOverScrollDeltaIndex();
1786     ASSERT_FALSE(index > 0);
1787 }
1788 } // namespace OHOS::Ace::NG
1789