1 /*
2  * Copyright (c) 2022-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 "gtest/gtest.h"
17 
18 #define private public
19 #define protected public
20 #include "test/mock/base/mock_task_executor.h"
21 #include "test/mock/core/render/mock_paragraph.h"
22 #include "test/mock/core/common/mock_container.h"
23 #include "test/mock/core/common/mock_theme_default.h"
24 
25 #include "base/geometry/axis.h"
26 #include "base/geometry/dimension.h"
27 #include "base/geometry/point.h"
28 #include "base/memory/ace_type.h"
29 #include "base/utils/utils.h"
30 #include "core/components/theme/app_theme.h"
31 #include "core/components_ng/base/view_stack_processor.h"
32 #include "core/components_ng/layout/layout_wrapper.h"
33 #include "core/components_ng/pattern/image/image_pattern.h"
34 #include "core/components_ng/pattern/slider/slider_accessibility_property.h"
35 #include "core/components_ng/pattern/slider/slider_event_hub.h"
36 #include "core/components_ng/pattern/slider/slider_layout_algorithm.h"
37 #include "core/components_ng/pattern/slider/slider_layout_property.h"
38 #include "core/components_ng/pattern/slider/slider_model.h"
39 #include "core/components_ng/pattern/slider/slider_model_ng.h"
40 #include "core/components_ng/pattern/slider/slider_paint_method.h"
41 #include "core/components_ng/pattern/slider/slider_paint_property.h"
42 #include "core/components_ng/pattern/slider/slider_pattern.h"
43 #include "core/components_ng/pattern/slider/slider_style.h"
44 #include "core/components_ng/render/drawing_mock.h"
45 #include "test/mock/core/rosen/mock_canvas.h"
46 #include "test/mock/core/common/mock_theme_manager.h"
47 #include "core/components_v2/inspector/inspector_constants.h"
48 #include "test/mock/core/pipeline/mock_pipeline_context.h"
49 
50 using namespace testing;
51 using namespace testing::ext;
52 
53 namespace OHOS::Ace::NG {
54 namespace {
55 const InspectorFilter filter;
56 constexpr float VALUE = 50.0f;
57 constexpr float STEP = 1.0f;
58 constexpr float MIN = 0.0f;
59 constexpr float MAX = 100.0f;
60 const Color TEST_COLOR = Color::BLUE;
61 constexpr float MAX_WIDTH = 500.0f;
62 constexpr float MAX_HEIGHT = 500.0f;
63 const SizeF MAX_SIZE(MAX_WIDTH, MAX_HEIGHT);
64 constexpr float FRAME_WIDTH = 10.0f;
65 constexpr float FRAME_HEIGHT = 20.0f;
66 constexpr Dimension RADIUS = Dimension(10.0);
67 constexpr float SLIDER_WIDTH = 10.0f;
68 constexpr float SLIDER_HEIGHT = 20.0f;
69 constexpr float SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS = 10.0f;
70 constexpr float SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS_DIFF = 1.0f;
71 constexpr float SLIDER_CONTENT_MODIFIER_TRACK_BORDER_RADIUS = 10.0f;
72 constexpr float SLIDER_CONTENT_MODIFIER_SELECTED_BORDER_RADIUS = 10.0f;
73 constexpr float SLIDER_CONTENT_MODIFIER_STEP_SIZE = 10.0f;
74 constexpr float SLIDER_CONTENT_MODIFIER_STEP_RATIO = 10000.0f;
75 constexpr float SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH = 10.0f;
76 constexpr float SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH_SMALL = 8.0f;
77 constexpr float HALF = 0.5;
78 constexpr float CONTAINER_WIDTH = 300.0f;
79 constexpr float CONTAINER_HEIGHT = 300.0f;
80 const SizeF CONTAINER_SIZE(CONTAINER_WIDTH, CONTAINER_HEIGHT);
81 constexpr Dimension BLOCK_SIZE_WIDTH = Dimension(300.0);
82 constexpr Dimension BLOCK_SIZE_HEIGHT = Dimension(300.0);
83 const SizeT<Dimension> BLOCK_SIZE(BLOCK_SIZE_WIDTH, BLOCK_SIZE_HEIGHT);
84 const std::string SLIDER_MODEL_NG_BLOCK_IMAGE = "Default Image";
85 const std::string SLIDER_TEST_BUNDLE_NAME = "com.test.slider";
86 const std::string SLIDER_TEST_MODULE_NAME = "testModule";
87 const PointF POINTF_START { 10.0f, 10.0f };
88 const PointF POINTF_END { 20.0f, 20.0f };
89 const PointF POINTF_START_DIFFX { 20.0f, 10.0f };
90 const PointF POINTF_END_DIFFX { 10.0f, 20.0f };
91 const PointF POINTF_START_DIFFY { 10.0f, 20.0f };
92 const PointF POINTF_END_DIFFY { 20.0f, 10.0f };
93 const PointF SELECT_START { 10.0f, 10.0f };
94 const PointF SELECT_END { 20.0f, 20.0f };
95 const PointF POINTF_CENTER { 15.0f, 15.0f };
96 const Dimension RADIUS_X = Dimension(20.1, DimensionUnit::PX);
97 const Dimension RADIUS_Y = Dimension(20.1, DimensionUnit::PX);
98 const Dimension SHAPE_WIDTH = 10.0_vp;
99 const Dimension SHAPE_HEIGHT = 20.0_vp;
100 const OffsetF SLIDER_GLOBAL_OFFSET = { 200.0f, 200.0f };
101 const SizeF BLOCK_SIZE_F(10.0f, 10.0f);
102 const SizeF BLOCK_SIZE_F_ZREO(0.0f, 0.0f);
103 constexpr float SLIDER_NEGATIVE = -5.0f;
104 constexpr Dimension BUBBLE_VERTICAL_SUITABLEAGING_LEVEL_1_WIDTH = 92.0_vp;
105 constexpr Dimension BUBBLE_VERTICAL_SUITABLEAGING_LEVEL_1_HEIGHT = 52.0_vp;
106 constexpr Dimension BUBBLE_HORIZONTAL_SUITABLEAGING_LEVEL_1_WIDTH = 48.0_vp;
107 constexpr Dimension BUBBLE_HORIZONTAL_SUITABLEAGING_LEVEL_1_HEIGHT = 60.0_vp;
108 constexpr Dimension BUBBLE_VERTICAL_SUITABLEAGING_LEVEL_2_WIDTH = 96.0_vp;
109 constexpr Dimension BUBBLE_VERTICAL_SUITABLEAGING_LEVEL_2_HEIGHT = 56.0_vp;
110 constexpr Dimension BUBBLE_HORIZONTAL_SUITABLEAGING_LEVEL_2_WIDTH = 48.0_vp;
111 constexpr Dimension BUBBLE_HORIZONTAL_SUITABLEAGING_LEVEL_2_HEIGHT = 64.0_vp;
112 constexpr Dimension SUITABLEAGING_LEVEL_1_TEXT_FONT_SIZE = 25.0_vp;
113 constexpr Dimension SUITABLEAGING_LEVEL_2_TEXT_FONT_SIZE = 28.0_vp;
114 } // namespace
115 class SliderModifierTestNg : public testing::Test {
116 public:
117     void SetUp() override;
118     void TearDown() override;
119 
120     static void SetUpTestSuite();
121     static void TearDownTestSuite();
122 
123 private:
124     void SetSliderContentModifier(SliderContentModifier& sliderContentModifier);
125     void MockCanvasFunction(Testing::MockCanvas& canvas);
126     void MockTipsCanvasFunction(Testing::MockCanvas& canvas);
127     void MockParagraphFunction(RefPtr<MockParagraph>& paragraph, Testing::MockCanvas& canvas);
128 };
129 
SetUpTestSuite()130 void SliderModifierTestNg::SetUpTestSuite()
131 {
132     MockPipelineContext::SetUp();
133 }
134 
TearDownTestSuite()135 void SliderModifierTestNg::TearDownTestSuite()
136 {
137     MockPipelineContext::TearDown();
138 }
139 
SetUp()140 void SliderModifierTestNg::SetUp()
141 {
142     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
143     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
144     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SliderTheme>()));
145 }
146 
TearDown()147 void SliderModifierTestNg::TearDown()
148 {
149     MockParagraph::TearDown();
150 }
151 
SetSliderContentModifier(SliderContentModifier & sliderContentModifier)152 void SliderModifierTestNg::SetSliderContentModifier(SliderContentModifier& sliderContentModifier)
153 {
154     sliderContentModifier.InitializeShapeProperty();
155     sliderContentModifier.SetTrackThickness(SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS);
156     sliderContentModifier.SetTrackBorderRadius(SLIDER_CONTENT_MODIFIER_TRACK_BORDER_RADIUS);
157     sliderContentModifier.SetSelectedBorderRadius(SLIDER_CONTENT_MODIFIER_SELECTED_BORDER_RADIUS);
158     sliderContentModifier.SetShowSteps(true);
159     sliderContentModifier.SetStepSize(SLIDER_CONTENT_MODIFIER_STEP_SIZE);
160     sliderContentModifier.SetStepColor(TEST_COLOR);
161     sliderContentModifier.SetStepRatio(SLIDER_CONTENT_MODIFIER_STEP_RATIO);
162     sliderContentModifier.SetBackgroundSize(POINTF_START, POINTF_END);
163     sliderContentModifier.SetBlockColor(TEST_COLOR);
164     SizeF blockSize;
165     sliderContentModifier.SetBlockSize(blockSize);
166 }
167 
MockCanvasFunction(Testing::MockCanvas & canvas)168 void SliderModifierTestNg::MockCanvasFunction(Testing::MockCanvas& canvas)
169 {
170     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
171     EXPECT_CALL(canvas, DrawRoundRect(_)).WillRepeatedly(Return());
172     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
173     EXPECT_CALL(canvas, DrawCircle(_, _)).WillRepeatedly(Return());
174     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
175     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
176     EXPECT_CALL(canvas, Save()).WillRepeatedly(Return());
177     EXPECT_CALL(canvas, Scale(_, _)).WillRepeatedly(Return());
178     EXPECT_CALL(canvas, Translate(_, _)).WillRepeatedly(Return());
179     EXPECT_CALL(canvas, Restore()).WillRepeatedly(Return());
180     EXPECT_CALL(canvas, ClipRect(_, _, _)).WillRepeatedly(Return());
181     EXPECT_CALL(canvas, DrawPath(_)).WillRepeatedly(Return());
182 }
183 
MockTipsCanvasFunction(Testing::MockCanvas & canvas)184 void SliderModifierTestNg::MockTipsCanvasFunction(Testing::MockCanvas& canvas)
185 {
186     EXPECT_CALL(canvas, Save()).WillRepeatedly(Return());
187     EXPECT_CALL(canvas, Scale(_, _)).WillRepeatedly(Return());
188     EXPECT_CALL(canvas, Translate(_, _)).WillRepeatedly(Return());
189     EXPECT_CALL(canvas, Restore()).WillRepeatedly(Return());
190     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
191     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
192     EXPECT_CALL(canvas, DrawPath(_)).WillRepeatedly(Return());
193     EXPECT_CALL(canvas, ClipPath(_, _, _)).WillRepeatedly(Return());
194 }
195 
MockParagraphFunction(RefPtr<MockParagraph> & paragraph,Testing::MockCanvas & canvas)196 void SliderModifierTestNg::MockParagraphFunction(RefPtr<MockParagraph>& paragraph, Testing::MockCanvas& canvas)
197 {
198     EXPECT_CALL(*paragraph, Paint(An<RSCanvas&>(), _, _)).WillRepeatedly(Return());
199     EXPECT_CALL(*paragraph, Layout(_)).WillRepeatedly(Return());
200     EXPECT_CALL(*paragraph, PushStyle(_)).WillRepeatedly(Return());
201     EXPECT_CALL(*paragraph, AddText(_)).WillRepeatedly(Return());
202     EXPECT_CALL(*paragraph, Build()).WillRepeatedly(Return());
203     EXPECT_CALL(*paragraph, GetTextWidth()).WillRepeatedly(Return(1.0f));
204     EXPECT_CALL(*paragraph, GetHeight()).WillRepeatedly(Return(1.0f));
205 }
206 
207 /**
208  * @tc.name: SliderContentModifierTest001
209  * @tc.desc: TEST slider_content_modifier onDraw
210  * direction = HORIZONTAL, blockType = DEFAULT, blockShape = CIRCLE, sliderMode = OUTSET
211  * @tc.type: FUNC
212  */
213 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest001, TestSize.Level1)
214 {
215     /**
216      * @tc.steps: step1. create frameNode and sliderContentModifier.
217      */
218     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
219     ASSERT_NE(sliderPattern, nullptr);
220     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
221     ASSERT_NE(frameNode, nullptr);
222     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
223     ASSERT_NE(sliderPaintProperty, nullptr);
224     SliderContentModifier::Parameters parameters;
225     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
226     /**
227      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
228      */
229     SetSliderContentModifier(sliderContentModifier);
230     sliderContentModifier.SetSelectSize(POINTF_START, POINTF_END);
231     sliderContentModifier.SetCircleCenter(POINTF_CENTER);
232     // set direction FREE
233     sliderContentModifier.SetDirection(Axis::FREE);
234     sliderContentModifier.SetCircleCenter(POINTF_CENTER);
235     // set animatorStatus default
236     sliderContentModifier.SetAnimatorStatus(SliderStatus::DEFAULT);
237     sliderContentModifier.SetSelectSize(POINTF_START, POINTF_END);
238     sliderContentModifier.SetCircleCenter(POINTF_CENTER);
239     // set Axis HORIZONTAL
240     sliderContentModifier.SetDirection(Axis::HORIZONTAL);
241     // set BlockStyleType DEFAULT
242     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::DEFAULT);
243     // set BasicShapeType CIRCLE
244     auto basicShape = AceType::MakeRefPtr<BasicShape>(BasicShapeType::CIRCLE);
245     sliderContentModifier.SetBlockShape(basicShape);
246     // set SliderMode OUTSET
247     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::OUTSET);
248     sliderContentModifier.SetBlockBorderColor(TEST_COLOR);
249     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
250     Testing::MockCanvas canvas;
251     MockCanvasFunction(canvas);
252     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
253     sliderContentModifier.onDraw(context);
254     EXPECT_EQ(sliderContentModifier.isShowStep_->Get(), true);
255     EXPECT_EQ(sliderContentModifier.stepSize_->Get(), SLIDER_CONTENT_MODIFIER_STEP_SIZE);
256     EXPECT_EQ(sliderContentModifier.stepColor_->Get(), LinearColor(TEST_COLOR));
257     EXPECT_EQ(sliderContentModifier.stepRatio_->Get(), SLIDER_CONTENT_MODIFIER_STEP_RATIO);
258     EXPECT_EQ(sliderContentModifier.directionAxis_->Get(), static_cast<int>(Axis::HORIZONTAL));
259     EXPECT_EQ(sliderContentModifier.blockType_->Get(), static_cast<int>(SliderModelNG::BlockStyleType::DEFAULT));
260     EXPECT_EQ(sliderContentModifier.shape_, basicShape);
261     EXPECT_EQ(sliderContentModifier.sliderMode_->Get(), static_cast<int>(SliderModelNG::SliderMode::OUTSET));
262     EXPECT_EQ(sliderContentModifier.blockBorderWidth_->Get(), SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
263 }
264 
265 /**
266  * @tc.name: SliderContentModifierTest002
267  * @tc.desc: TEST slider_content_modifier onDraw
268  * direction = HORIZONTAL, blockType = SHAPE, blockShape = CIRCLE, sliderMode = OUTSET
269  * @tc.type: FUNC
270  */
271 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest002, TestSize.Level1)
272 {
273     /**
274      * @tc.steps: step1. create frameNode and sliderContentModifier.
275      */
276     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
277     ASSERT_NE(sliderPattern, nullptr);
278     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
279     ASSERT_NE(frameNode, nullptr);
280     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
281     ASSERT_NE(sliderPaintProperty, nullptr);
282     SliderContentModifier::Parameters parameters;
283     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
284     /**
285      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
286      */
287     SetSliderContentModifier(sliderContentModifier);
288     sliderContentModifier.GetBlockCenter();
289     sliderContentModifier.GetTrackThickness();
290     sliderContentModifier.GetBlockSize();
291     // set Axis HORIZONTAL
292     sliderContentModifier.SetDirection(Axis::HORIZONTAL);
293     // set BlockStyleType SHAPE
294     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
295     // set BasicShapeType CIRCLE
296     auto basicShape = AceType::MakeRefPtr<Circle>();
297     basicShape->SetBasicShapeType(BasicShapeType::CIRCLE);
298     sliderContentModifier.SetBlockShape(basicShape);
299     // set SliderMode OUTSET
300     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::OUTSET);
301     sliderContentModifier.SetBlockBorderColor(TEST_COLOR);
302     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
303     Testing::MockCanvas canvas;
304     MockCanvasFunction(canvas);
305     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
306     sliderContentModifier.onDraw(context);
307     EXPECT_EQ(sliderContentModifier.trackThickness_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS);
308     EXPECT_EQ(sliderContentModifier.trackBorderRadius_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_BORDER_RADIUS);
309     EXPECT_EQ(sliderContentModifier.selectedBorderRadius_->Get(), SLIDER_CONTENT_MODIFIER_SELECTED_BORDER_RADIUS);
310     EXPECT_EQ(sliderContentModifier.isShowStep_->Get(), true);
311     EXPECT_EQ(sliderContentModifier.stepSize_->Get(), SLIDER_CONTENT_MODIFIER_STEP_SIZE);
312     EXPECT_EQ(sliderContentModifier.stepColor_->Get(), LinearColor(TEST_COLOR));
313     EXPECT_EQ(sliderContentModifier.stepRatio_->Get(), SLIDER_CONTENT_MODIFIER_STEP_RATIO);
314     EXPECT_EQ(sliderContentModifier.directionAxis_->Get(), static_cast<int>(Axis::HORIZONTAL));
315     EXPECT_EQ(sliderContentModifier.blockType_->Get(), static_cast<int>(SliderModelNG::BlockStyleType::SHAPE));
316     EXPECT_EQ(sliderContentModifier.shape_, basicShape);
317     EXPECT_EQ(sliderContentModifier.sliderMode_->Get(), static_cast<int>(SliderModelNG::SliderMode::OUTSET));
318     EXPECT_EQ(sliderContentModifier.blockBorderWidth_->Get(), SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
319 }
320 
321 /**
322  * @tc.name: SliderContentModifierTest003
323  * @tc.desc: TEST slider_content_modifier onDraw
324  * direction = FREE, blockType = SHAPE, blockShape = CIRCLE, sliderMode = OUTSET
325  * @tc.type: FUNC
326  */
327 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest003, TestSize.Level1)
328 {
329     /**
330      * @tc.steps: step1. create frameNode and sliderContentModifier.
331      */
332     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
333     ASSERT_NE(sliderPattern, nullptr);
334     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
335     ASSERT_NE(frameNode, nullptr);
336     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
337     ASSERT_NE(sliderPaintProperty, nullptr);
338     SliderContentModifier::Parameters parameters;
339     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
340     /**
341      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
342      */
343     SetSliderContentModifier(sliderContentModifier);
344     // set Axis FREE
345     sliderContentModifier.SetDirection(Axis::FREE);
346     // set BlockStyleType SHAPE
347     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
348     // set BasicShapeType CIRCLE
349     auto basicShape = AceType::MakeRefPtr<Circle>();
350     basicShape->SetBasicShapeType(BasicShapeType::CIRCLE);
351     auto circle = AceType::DynamicCast<Circle>(basicShape);
352     circle->SetRadius(RADIUS);
353     sliderContentModifier.SetBlockShape(basicShape);
354     // set SliderMode OUTSET
355     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::OUTSET);
356     sliderContentModifier.SetBlockBorderColor(TEST_COLOR);
357     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
358     Testing::MockCanvas canvas;
359     MockCanvasFunction(canvas);
360     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
361     sliderContentModifier.onDraw(context);
362     EXPECT_EQ(sliderContentModifier.trackThickness_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS);
363     EXPECT_EQ(sliderContentModifier.trackBorderRadius_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_BORDER_RADIUS);
364     EXPECT_EQ(sliderContentModifier.isShowStep_->Get(), true);
365     EXPECT_EQ(sliderContentModifier.stepSize_->Get(), SLIDER_CONTENT_MODIFIER_STEP_SIZE);
366     EXPECT_EQ(sliderContentModifier.stepColor_->Get(), LinearColor(TEST_COLOR));
367     EXPECT_EQ(sliderContentModifier.stepRatio_->Get(), SLIDER_CONTENT_MODIFIER_STEP_RATIO);
368     EXPECT_EQ(sliderContentModifier.directionAxis_->Get(), static_cast<int>(Axis::FREE));
369     EXPECT_EQ(sliderContentModifier.blockType_->Get(), static_cast<int>(SliderModelNG::BlockStyleType::SHAPE));
370     EXPECT_EQ(sliderContentModifier.shape_, basicShape);
371     EXPECT_EQ(sliderContentModifier.sliderMode_->Get(), static_cast<int>(SliderModelNG::SliderMode::OUTSET));
372     EXPECT_EQ(sliderContentModifier.blockBorderWidth_->Get(), SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
373 }
374 
375 /**
376  * @tc.name: SliderContentModifierTest004
377  * @tc.desc: TEST slider_content_modifier onDraw and DrawSelect
378  * direction = HORIZONTAL, blockType = SHAPE, blockShape = CIRCLE, sliderMode = INSET
379  * @tc.type: FUNC
380  */
381 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest004, TestSize.Level1)
382 {
383     /**
384      * @tc.steps: step1. create frameNode and sliderContentModifier.
385      */
386     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
387     ASSERT_NE(sliderPattern, nullptr);
388     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
389     ASSERT_NE(frameNode, nullptr);
390     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
391     ASSERT_NE(sliderPaintProperty, nullptr);
392     SliderContentModifier::Parameters parameters;
393     parameters.selectStart = SELECT_START;
394     parameters.selectEnd = SELECT_END;
395     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
396     /**
397      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
398      */
399     SetSliderContentModifier(sliderContentModifier);
400     // set Axis HORIZONTAL
401     sliderContentModifier.SetDirection(Axis::HORIZONTAL);
402     // set BlockStyleType SHAPE
403     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
404     // set BasicShapeType CIRCLE
405     auto basicShape = AceType::MakeRefPtr<Circle>();
406     basicShape->SetBasicShapeType(BasicShapeType::CIRCLE);
407     sliderContentModifier.SetBlockShape(basicShape);
408     // set SliderMode OUTSET
409     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::INSET);
410     sliderContentModifier.SetBlockBorderColor(TEST_COLOR);
411     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
412     Testing::MockCanvas canvas;
413     MockCanvasFunction(canvas);
414     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
415     sliderContentModifier.onDraw(context);
416     sliderContentModifier.DrawSelect(context);
417     sliderContentModifier.SetDirection(Axis::FREE);
418     sliderContentModifier.DrawSelect(context);
419     sliderContentModifier.reverse_ = true;
420     sliderContentModifier.DrawSelect(context);
421     sliderContentModifier.SetDirection(Axis::HORIZONTAL);
422     sliderContentModifier.DrawSelect(context);
423     EXPECT_EQ(sliderContentModifier.isShowStep_->Get(), true);
424     EXPECT_EQ(sliderContentModifier.stepSize_->Get(), SLIDER_CONTENT_MODIFIER_STEP_SIZE);
425     EXPECT_EQ(sliderContentModifier.stepColor_->Get(), LinearColor(TEST_COLOR));
426     EXPECT_EQ(sliderContentModifier.stepRatio_->Get(), SLIDER_CONTENT_MODIFIER_STEP_RATIO);
427     EXPECT_EQ(sliderContentModifier.directionAxis_->Get(), static_cast<int>(Axis::HORIZONTAL));
428     EXPECT_EQ(sliderContentModifier.blockType_->Get(), static_cast<int>(SliderModelNG::BlockStyleType::SHAPE));
429     EXPECT_EQ(sliderContentModifier.shape_, basicShape);
430     EXPECT_EQ(sliderContentModifier.sliderMode_->Get(), static_cast<int>(SliderModelNG::SliderMode::INSET));
431     EXPECT_EQ(sliderContentModifier.blockBorderWidth_->Get(), SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
432 }
433 
434 /**
435  * @tc.name: SliderContentModifierTest005
436  * @tc.desc: TEST slider_content_modifier onDraw
437  * direction = FREE, blockType = SHAPE, blockShape = CIRCLE, sliderMode = OUTSET
438  * @tc.type: FUNC
439  */
440 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest005, TestSize.Level1)
441 {
442     /**
443      * @tc.steps: step1. create frameNode and sliderContentModifier.
444      */
445     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
446     ASSERT_NE(sliderPattern, nullptr);
447     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
448     ASSERT_NE(frameNode, nullptr);
449     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
450     ASSERT_NE(sliderPaintProperty, nullptr);
451     SliderContentModifier::Parameters parameters;
452     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
453     /**
454      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
455      */
456     SetSliderContentModifier(sliderContentModifier);
457     // set Axis FREE
458     sliderContentModifier.SetDirection(Axis::FREE);
459     // set BlockStyleType SHAPE
460     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
461     // set BasicShapeType CIRCLE
462     auto basicShape = AceType::MakeRefPtr<Circle>();
463     basicShape->SetBasicShapeType(BasicShapeType::CIRCLE);
464     sliderContentModifier.SetBlockShape(basicShape);
465     // set SliderMode OUTSET
466     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::OUTSET);
467     sliderContentModifier.SetBlockBorderColor(TEST_COLOR);
468     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
469     Testing::MockCanvas canvas;
470     MockCanvasFunction(canvas);
471     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
472     sliderContentModifier.onDraw(context);
473     EXPECT_EQ(sliderContentModifier.trackThickness_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS);
474     EXPECT_EQ(sliderContentModifier.trackBorderRadius_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_BORDER_RADIUS);
475     EXPECT_EQ(sliderContentModifier.isShowStep_->Get(), true);
476     EXPECT_EQ(sliderContentModifier.stepSize_->Get(), SLIDER_CONTENT_MODIFIER_STEP_SIZE);
477     EXPECT_EQ(sliderContentModifier.stepColor_->Get(), LinearColor(TEST_COLOR));
478     EXPECT_EQ(sliderContentModifier.stepRatio_->Get(), SLIDER_CONTENT_MODIFIER_STEP_RATIO);
479     EXPECT_EQ(sliderContentModifier.directionAxis_->Get(), static_cast<int>(Axis::FREE));
480     EXPECT_EQ(sliderContentModifier.blockType_->Get(), static_cast<int>(SliderModelNG::BlockStyleType::SHAPE));
481     EXPECT_EQ(sliderContentModifier.shape_, basicShape);
482     EXPECT_EQ(sliderContentModifier.sliderMode_->Get(), static_cast<int>(SliderModelNG::SliderMode::OUTSET));
483     EXPECT_EQ(sliderContentModifier.blockBorderWidth_->Get(), SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
484 }
485 
486 /**
487  * @tc.name: SliderContentModifierTest006
488  * @tc.desc: TEST slider_content_modifier onDraw
489  * direction = FREE, blockType = SHAPE, blockShape = ELLIPSE, sliderMode = OUTSET
490  * @tc.type: FUNC
491  */
492 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest006, TestSize.Level1)
493 {
494     /**
495      * @tc.steps: step1. create frameNode and sliderContentModifier.
496      */
497     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
498     ASSERT_NE(sliderPattern, nullptr);
499     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
500     ASSERT_NE(frameNode, nullptr);
501     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
502     ASSERT_NE(sliderPaintProperty, nullptr);
503     SliderContentModifier::Parameters parameters;
504     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
505     /**
506      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
507      */
508     SetSliderContentModifier(sliderContentModifier);
509     // set Axis FREE
510     sliderContentModifier.SetDirection(Axis::FREE);
511     // set BlockStyleType SHAPE
512     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
513     // set BasicShapeType ELLIPSE
514     auto basicShape = AceType::MakeRefPtr<Ellipse>();
515     basicShape->SetBasicShapeType(BasicShapeType::ELLIPSE);
516     basicShape->SetRadiusX(RADIUS_X);
517     basicShape->SetRadiusY(RADIUS_Y);
518     sliderContentModifier.SetBlockShape(basicShape);
519     // set SliderMode OUTSET
520     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::OUTSET);
521     sliderContentModifier.SetBlockBorderColor(TEST_COLOR);
522     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
523     Testing::MockCanvas canvas;
524     MockCanvasFunction(canvas);
525     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
526     sliderContentModifier.onDraw(context);
527     EXPECT_EQ(sliderContentModifier.trackThickness_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS);
528     EXPECT_EQ(sliderContentModifier.trackBorderRadius_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_BORDER_RADIUS);
529     EXPECT_EQ(sliderContentModifier.isShowStep_->Get(), true);
530     EXPECT_EQ(sliderContentModifier.stepSize_->Get(), SLIDER_CONTENT_MODIFIER_STEP_SIZE);
531     EXPECT_EQ(sliderContentModifier.stepColor_->Get(), LinearColor(TEST_COLOR));
532     EXPECT_EQ(sliderContentModifier.stepRatio_->Get(), SLIDER_CONTENT_MODIFIER_STEP_RATIO);
533     EXPECT_EQ(sliderContentModifier.directionAxis_->Get(), static_cast<int>(Axis::FREE));
534     EXPECT_EQ(sliderContentModifier.blockType_->Get(), static_cast<int>(SliderModelNG::BlockStyleType::SHAPE));
535     EXPECT_EQ(sliderContentModifier.shape_, basicShape);
536     EXPECT_EQ(sliderContentModifier.sliderMode_->Get(), static_cast<int>(SliderModelNG::SliderMode::OUTSET));
537     EXPECT_EQ(sliderContentModifier.blockBorderWidth_->Get(), SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
538 }
539 
540 /**
541  * @tc.name: SliderContentModifierTest007
542  * @tc.desc: TEST slider_content_modifier onDraw
543  * direction = FREE, blockType = SHAPE, blockShape = PATH, sliderMode = INSET
544  * @tc.type: FUNC
545  */
546 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest007, TestSize.Level1)
547 {
548     /**
549      * @tc.steps: step1. create frameNode and sliderContentModifier.
550      */
551     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
552     ASSERT_NE(sliderPattern, nullptr);
553     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
554     ASSERT_NE(frameNode, nullptr);
555     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
556     ASSERT_NE(sliderPaintProperty, nullptr);
557     SliderContentModifier::Parameters parameters;
558     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
559     /**
560      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
561      */
562     SetSliderContentModifier(sliderContentModifier);
563     // set Axis FREE
564     sliderContentModifier.SetDirection(Axis::FREE);
565     // set BlockStyleType SHAPE
566     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
567     // set BasicShapeType PATH
568     auto basicShape = AceType::MakeRefPtr<Path>();
569     basicShape->SetBasicShapeType(BasicShapeType::PATH);
570     basicShape->SetValue("PATH");
571     sliderContentModifier.SetBlockShape(basicShape);
572     // set SliderMode INSET
573     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::INSET);
574     sliderContentModifier.SetBlockBorderColor(TEST_COLOR);
575     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
576     sliderContentModifier.SetBlockSize(SizeF(BLOCK_SIZE_WIDTH.ConvertToPx(), BLOCK_SIZE_HEIGHT.ConvertToPx()));
577     Testing::MockCanvas canvas;
578     MockCanvasFunction(canvas);
579     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
580     sliderContentModifier.onDraw(context);
581     EXPECT_EQ(sliderContentModifier.trackThickness_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS);
582     EXPECT_EQ(sliderContentModifier.trackBorderRadius_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_BORDER_RADIUS);
583     EXPECT_EQ(sliderContentModifier.isShowStep_->Get(), true);
584     EXPECT_EQ(sliderContentModifier.stepSize_->Get(), SLIDER_CONTENT_MODIFIER_STEP_SIZE);
585     EXPECT_EQ(sliderContentModifier.stepColor_->Get(), LinearColor(TEST_COLOR));
586     EXPECT_EQ(sliderContentModifier.stepRatio_->Get(), SLIDER_CONTENT_MODIFIER_STEP_RATIO);
587     EXPECT_EQ(sliderContentModifier.directionAxis_->Get(), static_cast<int>(Axis::FREE));
588     EXPECT_EQ(sliderContentModifier.blockType_->Get(), static_cast<int>(SliderModelNG::BlockStyleType::SHAPE));
589     EXPECT_EQ(sliderContentModifier.shape_, basicShape);
590     EXPECT_EQ(sliderContentModifier.sliderMode_->Get(), static_cast<int>(SliderModelNG::SliderMode::INSET));
591     EXPECT_EQ(sliderContentModifier.blockBorderWidth_->Get(), SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
592 }
593 
594 /**
595  * @tc.name: SliderContentModifierTest008
596  * @tc.desc: TEST slider_content_modifier onDraw
597  * direction = FREE, blockType = SHAPE, blockShape = RECT, sliderMode = OUTSET
598  * @tc.type: FUNC
599  */
600 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest008, TestSize.Level1)
601 {
602     /**
603      * @tc.steps: step1. create frameNode and sliderContentModifier.
604      */
605     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
606     ASSERT_NE(sliderPattern, nullptr);
607     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
608     ASSERT_NE(frameNode, nullptr);
609     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
610     ASSERT_NE(sliderPaintProperty, nullptr);
611     SliderContentModifier::Parameters parameters;
612     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
613     /**
614      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
615      */
616     SetSliderContentModifier(sliderContentModifier);
617     // set Axis FREE
618     sliderContentModifier.SetDirection(Axis::FREE);
619     // set BlockStyleType SHAPE
620     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
621     // set BasicShapeType RECT
622     auto basicShape = AceType::MakeRefPtr<ShapeRect>();
623     basicShape->SetBasicShapeType(BasicShapeType::RECT);
624     sliderContentModifier.SetBlockShape(basicShape);
625     // set SliderMode OUTSET
626     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::OUTSET);
627     sliderContentModifier.SetBlockBorderColor(TEST_COLOR);
628     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
629     Testing::MockCanvas canvas;
630     MockCanvasFunction(canvas);
631     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
632     sliderContentModifier.onDraw(context);
633     EXPECT_EQ(sliderContentModifier.trackThickness_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS);
634     EXPECT_EQ(sliderContentModifier.trackBorderRadius_->Get(), SLIDER_CONTENT_MODIFIER_TRACK_BORDER_RADIUS);
635     EXPECT_EQ(sliderContentModifier.isShowStep_->Get(), true);
636     EXPECT_EQ(sliderContentModifier.stepSize_->Get(), SLIDER_CONTENT_MODIFIER_STEP_SIZE);
637     EXPECT_EQ(sliderContentModifier.stepColor_->Get(), LinearColor(TEST_COLOR));
638     EXPECT_EQ(sliderContentModifier.stepRatio_->Get(), SLIDER_CONTENT_MODIFIER_STEP_RATIO);
639     EXPECT_EQ(sliderContentModifier.directionAxis_->Get(), static_cast<int>(Axis::FREE));
640     EXPECT_EQ(sliderContentModifier.blockType_->Get(), static_cast<int>(SliderModelNG::BlockStyleType::SHAPE));
641     EXPECT_EQ(sliderContentModifier.shape_, basicShape);
642     EXPECT_EQ(sliderContentModifier.sliderMode_->Get(), static_cast<int>(SliderModelNG::SliderMode::OUTSET));
643     EXPECT_EQ(sliderContentModifier.blockBorderWidth_->Get(), SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH);
644 }
645 
646 /**
647  * @tc.name: SliderContentModifierTest009
648  * @tc.desc: TEST slider_content_modifier SetBlockShape with invalid circle
649  * @tc.type: FUNC
650  */
651 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest009, TestSize.Level1)
652 {
653     /**
654      * @tc.steps: step1. create sliderContentModifier.
655      */
656     SliderContentModifier::Parameters parameters;
657     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
658     /**
659      * @tc.steps: step2. call SetBlockShape function with invalid circle.
660      */
661     auto basicShape = AceType::MakeRefPtr<Circle>();
662     ASSERT_NE(basicShape, nullptr);
663     basicShape->SetRadius(Dimension());
664     basicShape->SetWidth(SHAPE_WIDTH);
665     basicShape->SetHeight(SHAPE_HEIGHT);
666     sliderContentModifier.SetBlockShape(basicShape);
667     EXPECT_EQ(sliderContentModifier.circleRadius_->Get(), std::min(SHAPE_WIDTH, SHAPE_HEIGHT).ConvertToPx() * HALF);
668 }
669 
670 /**
671  * @tc.name: SliderContentModifierTest010
672  * @tc.desc: TEST slider_content_modifier SetBlockShape with invalid ellipse
673  * @tc.type: FUNC
674  */
675 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest010, TestSize.Level1)
676 {
677     /**
678      * @tc.steps: step1. create sliderContentModifier.
679      */
680     SliderContentModifier::Parameters parameters;
681     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
682     /**
683      * @tc.steps: step2. call SetBlockShape function with invalid ellipse.
684      */
685     auto basicShape = AceType::MakeRefPtr<Ellipse>();
686     ASSERT_NE(basicShape, nullptr);
687     basicShape->SetRadiusX(Dimension());
688     basicShape->SetRadiusY(Dimension());
689     basicShape->SetWidth(SHAPE_WIDTH);
690     basicShape->SetHeight(SHAPE_HEIGHT);
691     sliderContentModifier.SetBlockShape(basicShape);
692     EXPECT_EQ(sliderContentModifier.ellipseRadiusX_->Get(), SHAPE_WIDTH.ConvertToPx() * HALF);
693     EXPECT_EQ(sliderContentModifier.ellipseRadiusY_->Get(), SHAPE_HEIGHT.ConvertToPx() * HALF);
694 }
695 
696 /**
697  * @tc.name: SliderContentModifierTest011
698  * @tc.desc: TEST slider_content_modifier DrawBlockShape with invalid shape
699  * @tc.type: FUNC
700  */
701 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest011, TestSize.Level1)
702 {
703     /**
704      * @tc.steps: step1. create sliderContentModifier.
705      */
706     SliderContentModifier::Parameters parameters;
707     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
708     /**
709      * @tc.steps: step2. call SetBlockShape function with invalid shape.
710      */
711     auto basicShape = AceType::MakeRefPtr<BasicShape>();
712     ASSERT_NE(basicShape, nullptr);
713     basicShape->SetWidth(SHAPE_WIDTH);
714     basicShape->SetHeight(SHAPE_HEIGHT);
715     sliderContentModifier.SetBlockShape(basicShape);
716     Testing::MockCanvas canvas;
717     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
718     // Draw nothing
719     sliderContentModifier.DrawBlockShape(context);
720     EXPECT_CALL(canvas, AttachBrush(_)).Times(0);
721     EXPECT_CALL(canvas, AttachPen(_)).Times(0);
722 }
723 
724 /**
725  * @tc.name: SliderContentModifierTest012
726  * @tc.desc: TEST slider_content_modifier DrawStep with invalid parameter
727  * @tc.type: FUNC
728  */
729 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest012, TestSize.Level1)
730 {
731     /**
732      * @tc.steps: step1. create sliderContentModifier.
733      */
734     SliderContentModifier::Parameters parameters;
735     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
736     sliderContentModifier.isShowStep_->Set(true);
737     sliderContentModifier.stepRatio_->Set(.0f);
738     /**
739      * @tc.steps: step2. call DrawStep function with invalid parameter.
740      */
741     Testing::MockCanvas canvas;
742     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
743     // Draw nothing
744     sliderContentModifier.DrawStep(context);
745     EXPECT_CALL(canvas, AttachBrush(_)).Times(0);
746     EXPECT_CALL(canvas, AttachPen(_)).Times(0);
747 }
748 
749 /**
750  * @tc.name: SliderContentModifierTest013
751  * @tc.desc: Test DrawStep while not show step
752  * @tc.type: FUNC
753  */
754 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest013, TestSize.Level1)
755 {
756     SliderContentModifier::Parameters parameters;
757     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
758 
759     auto isShowStep = AceType::MakeRefPtr<PropertyBool>(false);
760     sliderContentModifier.isShowStep_ = isShowStep;
761     Testing::MockCanvas canvas;
762     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
763     sliderContentModifier.DrawStep(context);
764     EXPECT_FALSE(sliderContentModifier.isShowStep_->Get());
765 }
766 
767 /**
768  * @tc.name: SliderContentModifierTest014
769  * @tc.desc: Test JudgeNeedAnimate
770  * @tc.type: FUNC
771  */
772 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest014, TestSize.Level1)
773 {
774     SliderModelNG sliderModelNG;
775     sliderModelNG.Create(VALUE, STEP, MIN, MAX);
776     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
777     ASSERT_NE(frameNode, nullptr);
778 
779     SliderContentModifier::Parameters parameters;
780     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
781 
782     sliderContentModifier.reverse_ = true;
783     sliderContentModifier.JudgeNeedAnimate(false);
784     EXPECT_EQ(sliderContentModifier.animatorStatus_, SliderStatus::DEFAULT);
785     EXPECT_FALSE(sliderContentModifier.reverse_);
786 }
787 
788 /**
789  * @tc.name: SliderContentModifierTest015
790  * @tc.desc: Test SetSelectSize while need needAnimate
791  * @tc.type: FUNC
792  */
793 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest015, TestSize.Level1)
794 {
795     SliderContentModifier::Parameters parameters;
796     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
797     ASSERT_NE(sliderContentModifier.selectEnd_, nullptr);
798 
799     sliderContentModifier.animatorStatus_ = SliderStatus::MOVE;
800     sliderContentModifier.SetSelectSize(POINTF_START, POINTF_END);
801     EXPECT_EQ(sliderContentModifier.selectEnd_->Get(), POINTF_END - PointF());
802 }
803 
804 /**
805  * @tc.name: SliderContentModifierTest016
806  * @tc.desc: Test SetCircleCenter while needAnimate
807  * @tc.type: FUNC
808  */
809 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest016, TestSize.Level1)
810 {
811     SliderContentModifier::Parameters parameters;
812     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
813     ASSERT_NE(sliderContentModifier.blockCenterX_, nullptr);
814     ASSERT_NE(sliderContentModifier.blockCenterY_, nullptr);
815 
816     sliderContentModifier.animatorStatus_ = SliderStatus::MOVE;
817     PointF center(FRAME_WIDTH, FRAME_HEIGHT);
818     sliderContentModifier.directionAxis_->Set(static_cast<int>(Axis::HORIZONTAL));
819     sliderContentModifier.SetCircleCenter(center);
820     EXPECT_EQ(sliderContentModifier.blockCenterX_->Get(), FRAME_WIDTH);
821     EXPECT_EQ(sliderContentModifier.blockCenterY_->Get(), FRAME_HEIGHT);
822 
823     sliderContentModifier.directionAxis_->Set(static_cast<int>(Axis::VERTICAL));
824     sliderContentModifier.SetCircleCenter(center);
825     EXPECT_EQ(sliderContentModifier.blockCenterX_->Get(), FRAME_WIDTH);
826     EXPECT_EQ(sliderContentModifier.blockCenterY_->Get(), FRAME_HEIGHT);
827 
828     sliderContentModifier.directionAxis_->Set(static_cast<int>(Axis::NONE));
829     sliderContentModifier.SetCircleCenter(PointF(FRAME_WIDTH, FRAME_WIDTH));
830     EXPECT_EQ(sliderContentModifier.blockCenterX_->Get(), FRAME_WIDTH);
831     EXPECT_EQ(sliderContentModifier.blockCenterY_->Get(), FRAME_WIDTH);
832 }
833 
834 /**
835  * @tc.name: SliderContentModifierTest017
836  * @tc.desc: Test DrawBlock while blockType is image
837  * @tc.type: FUNC
838  */
839 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest017, TestSize.Level1)
840 {
841     /**
842      * @tc.steps: step1. create content modifier and set image block property.
843      */
844     SliderContentModifier::Parameters parameters;
845     OffsetF value;
__anond83fed490202(float x) 846     auto updateImageCenterX = [&value](float x) { value.SetX(x); };
__anond83fed490302(float y) 847     auto updateImageCenterY = [&value](float y) { value.SetY(y); };
848     SliderContentModifier sliderContentModifier(parameters, updateImageCenterX, updateImageCenterY);
849     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::IMAGE);
850 
851     /**
852      * @tc.steps: step2. start SliderContentModifier SetCircleCenter func.
853      * @tc.cases: case1. when the block center changes.
854      */
855     PointF center(FRAME_WIDTH, FRAME_HEIGHT);
856     sliderContentModifier.SetCircleCenter(center);
857     Testing::MockCanvas canvas;
858     MockCanvasFunction(canvas);
859     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
860     sliderContentModifier.DrawBlock(context);
861     EXPECT_EQ(value.GetY(), FRAME_HEIGHT);
862 
863     SliderContentModifier sliderContentModifierPro(parameters, nullptr, nullptr);
864     sliderContentModifierPro.SetBlockType(SliderModelNG::BlockStyleType::IMAGE);
865     sliderContentModifierPro.DrawBlock(context);
866     EXPECT_EQ(sliderContentModifierPro.updateImageCenterX_, nullptr);
867     EXPECT_EQ(sliderContentModifierPro.updateImageCenterX_, nullptr);
868 }
869 
870 /**
871  * @tc.name: SliderContentModifierTest018
872  * @tc.desc: Test StopSelectAnimation Function
873  * @tc.type: FUNC
874  */
875 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest018, TestSize.Level1)
876 {
877     /**
878      * @tc.steps: step1. create content modifier and set property callback.
879      */
880     SliderContentModifier::Parameters parameters;
881     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
882     OffsetF value;
883     bool set = false;
__anond83fed490402(const OffsetF& arg) 884     auto animatablePropertySetCallback = [&value, &set](const OffsetF& arg) {
885         value = arg;
886         set = true;
887     };
__anond83fed490502() 888     auto animatablePropertyGetCallback = [&value]() { return value; };
889     sliderContentModifier.selectEnd_->SetUpCallbacks(animatablePropertyGetCallback, animatablePropertySetCallback);
890 
891     /**
892      * @tc.steps: step2. start SliderContentModifier StopSelectAnimation func.
893      * @tc.cases: case1. when sliderPaintProperty's direction is HORIZONTAL.
894      */
895     sliderContentModifier.directionAxis_->Set(static_cast<int>(Axis::HORIZONTAL));
896     sliderContentModifier.selectEnd_->Set(POINTF_CENTER - PointF());
897     sliderContentModifier.targetSelectEnd_ = SELECT_START - PointF();
898     sliderContentModifier.StopSelectAnimation();
899     ASSERT_TRUE(set);
900 
901     sliderContentModifier.selectEnd_->Set(POINTF_CENTER - PointF());
902     sliderContentModifier.targetSelectEnd_ = SELECT_END - PointF();
903     set = false;
904     sliderContentModifier.StopSelectAnimation();
905     ASSERT_TRUE(set);
906 
907     sliderContentModifier.selectEnd_->Set(SELECT_END - PointF());
908     sliderContentModifier.targetSelectEnd_ = POINTF_CENTER - PointF();
909     set = false;
910     sliderContentModifier.StopSelectAnimation();
911     ASSERT_TRUE(set);
912 
913     /**
914      * @tc.cases: case2. when sliderPaintProperty's direction is VERTICAL.
915      */
916     sliderContentModifier.directionAxis_->Set(static_cast<int>(Axis::VERTICAL));
917     sliderContentModifier.selectEnd_->Set(POINTF_CENTER - PointF());
918     sliderContentModifier.targetSelectEnd_ = SELECT_START - PointF();
919     set = false;
920     sliderContentModifier.StopSelectAnimation();
921     ASSERT_TRUE(set);
922 
923     sliderContentModifier.selectEnd_->Set(POINTF_CENTER - PointF());
924     sliderContentModifier.targetSelectEnd_ = SELECT_END - PointF();
925     set = false;
926     sliderContentModifier.StopSelectAnimation();
927     ASSERT_TRUE(set);
928 
929     sliderContentModifier.selectEnd_->Set(SELECT_END - PointF());
930     sliderContentModifier.targetSelectEnd_ = POINTF_CENTER - PointF();
931     set = false;
932     sliderContentModifier.StopSelectAnimation();
933     ASSERT_TRUE(set);
934 }
935 
936 /**
937  * @tc.name: SliderContentModifierTest019
938  * @tc.desc: Test StopSelectAnimation Function
939  * @tc.type: FUNC
940  */
941 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest019, TestSize.Level1)
942 {
943     /**
944      * @tc.steps: step1. create content modifier and set property callback.
945      */
946     SliderContentModifier::Parameters parameters;
947     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
948     float blockCenterX;
949     float blockCenterY;
950     bool set = false;
__anond83fed490602(const float& arg) 951     auto animatablePropertySetCallback = [&blockCenterX, &set](const float& arg) {
952         blockCenterX = arg;
953         set = true;
954     };
__anond83fed490702() 955     auto animatablePropertyGetCallback = [&blockCenterX]() { return blockCenterX; };
956     sliderContentModifier.blockCenterX_->SetUpCallbacks(animatablePropertyGetCallback, animatablePropertySetCallback);
957 
958     /**
959      * @tc.steps: step2. start SliderContentModifier StopCircleCenterAnimation func.
960      * @tc.cases: case1. when sliderPaintProperty's direction is HORIZONTAL.
961      */
962     sliderContentModifier.directionAxis_->Set(static_cast<int>(Axis::HORIZONTAL));
963     sliderContentModifier.blockCenterX_->Set(POINTF_CENTER.GetX());
964     sliderContentModifier.targetCenter_ = POINTF_START;
965     sliderContentModifier.StopCircleCenterAnimation();
966     ASSERT_TRUE(set);
967 
968     sliderContentModifier.blockCenterX_->Set(POINTF_CENTER.GetX());
969     sliderContentModifier.targetCenter_ = POINTF_END;
970     set = false;
971     sliderContentModifier.StopCircleCenterAnimation();
972     ASSERT_TRUE(set);
973 
974     sliderContentModifier.blockCenterX_->Set(POINTF_END.GetX());
975     sliderContentModifier.targetCenter_ = POINTF_CENTER;
976     set = false;
977     sliderContentModifier.StopCircleCenterAnimation();
978     ASSERT_TRUE(set);
979 
980     /**
981      * @tc.cases: case2. when sliderPaintProperty's direction is VERTICAL.
982      */
__anond83fed490802(const float& arg) 983     auto animatablePropertySetCallback2 = [&blockCenterY, &set](const float& arg) {
984         blockCenterY = arg;
985         set = true;
986     };
__anond83fed490902() 987     auto animatablePropertyGetCallback2 = [&blockCenterY]() { return blockCenterY; };
988     sliderContentModifier.blockCenterY_->SetUpCallbacks(animatablePropertyGetCallback2, animatablePropertySetCallback2);
989     sliderContentModifier.directionAxis_->Set(static_cast<int>(Axis::VERTICAL));
990     sliderContentModifier.blockCenterY_->Set(POINTF_CENTER.GetY());
991     sliderContentModifier.targetCenter_ = POINTF_START;
992     set = false;
993     sliderContentModifier.StopCircleCenterAnimation();
994     ASSERT_TRUE(set);
995 
996     sliderContentModifier.blockCenterY_->Set(POINTF_CENTER.GetY());
997     sliderContentModifier.targetCenter_ = POINTF_END;
998     set = false;
999     sliderContentModifier.StopCircleCenterAnimation();
1000     ASSERT_TRUE(set);
1001 
1002     sliderContentModifier.blockCenterY_->Set(POINTF_END.GetY());
1003     sliderContentModifier.targetCenter_ = POINTF_CENTER;
1004     set = false;
1005     sliderContentModifier.StopCircleCenterAnimation();
1006     ASSERT_TRUE(set);
1007 }
1008 
1009 /**
1010  * @tc.name: SliderContentModifierTest020
1011  * @tc.desc: TEST gradient track background
1012  * @tc.type: FUNC
1013  */
1014 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest020, TestSize.Level1)
1015 {
1016     /**
1017      * @tc.steps: step1. create frameNode and sliderContentModifier.
1018      */
1019     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1020     ASSERT_NE(sliderPattern, nullptr);
1021     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1022     ASSERT_NE(frameNode, nullptr);
1023     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1024     ASSERT_NE(sliderPaintProperty, nullptr);
1025     SliderContentModifier::Parameters parameters;
1026     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
1027     /**
1028      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
1029      */
1030     SetSliderContentModifier(sliderContentModifier);
1031 
1032     Gradient gradient;
1033     GradientColor gradientColor1;
1034     gradientColor1.SetLinearColor(LinearColor(Color::WHITE));
1035     gradientColor1.SetDimension(Dimension(0.0));
1036     gradient.AddColor(gradientColor1);
1037     GradientColor gradientColor2;
1038     gradientColor2.SetLinearColor(LinearColor(Color::RED));
1039     gradientColor2.SetDimension(Dimension(0.5));
1040     gradient.AddColor(gradientColor2);
1041     GradientColor gradientColor3;
1042     gradientColor3.SetLinearColor(LinearColor(Color::BLUE));
1043     gradientColor3.SetDimension(Dimension(1.0));
1044     gradient.AddColor(gradientColor3);
1045     std::vector<GradientColor> gradientColors = gradient.GetColors();
1046     sliderContentModifier.SetTrackBackgroundColor(gradient);
1047 
1048     Testing::MockCanvas canvas;
1049     MockCanvasFunction(canvas);
1050     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1051     sliderContentModifier.onDraw(context);
1052 
1053     Gradient gradient2 = sliderContentModifier.trackBackgroundColor_->Get().GetGradient();
1054     std::vector<GradientColor> gradientColors2 = gradient2.GetColors();
1055 
1056     EXPECT_EQ(gradientColors.size(), gradientColors2.size());
1057     EXPECT_EQ(gradientColors[0].GetLinearColor(), gradientColors2[0].GetLinearColor());
1058     EXPECT_EQ(gradientColors[1].GetLinearColor(), gradientColors2[1].GetLinearColor());
1059     EXPECT_EQ(gradientColors[2].GetLinearColor(), gradientColors2[2].GetLinearColor());
1060     EXPECT_EQ(gradientColors[0].GetDimension(), gradientColors2[0].GetDimension());
1061     EXPECT_EQ(gradientColors[1].GetDimension(), gradientColors2[1].GetDimension());
1062     EXPECT_EQ(gradientColors[2].GetDimension(), gradientColors2[2].GetDimension());
1063 }
1064 
1065 /**
1066  * @tc.name: SliderContentModifierTest021
1067  * @tc.desc: TEST default track background color
1068  * @tc.type: FUNC
1069  */
1070 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest021, TestSize.Level1)
1071 {
1072     /**
1073      * @tc.steps: step0. Mock track background default value
1074      */
1075     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1076     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1077     auto sliderTheme = AceType::MakeRefPtr<SliderTheme>();
1078     sliderTheme->trackBgColor_ = Color::RED;
1079     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(sliderTheme));
1080 
1081     /**
1082      * @tc.steps: step1. create frameNode and sliderContentModifier.
1083      */
1084     SliderModelNG sliderModelNG;
1085     sliderModelNG.Create(VALUE, STEP, MIN, MAX);
1086     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1087     EXPECT_NE(frameNode, nullptr);
1088 
1089     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1090     ASSERT_NE(sliderPattern, nullptr);
1091     sliderPattern->AttachToFrameNode(frameNode);
1092 
1093     auto geometryNode = frameNode->GetGeometryNode();
1094     ASSERT_NE(geometryNode, nullptr);
1095     geometryNode->SetContentSize(SizeF(MAX_WIDTH, MAX_HEIGHT));
1096 
1097     ASSERT_NE(sliderPattern->CreateNodePaintMethod(), nullptr);
1098     ASSERT_NE(sliderPattern->sliderContentModifier_, nullptr);
1099 
1100     Gradient gradient = sliderPattern->sliderContentModifier_->trackBackgroundColor_->Get().GetGradient();
1101     std::vector<GradientColor> gradientColors = gradient.GetColors();
1102 
1103     Gradient defaultGradient;
1104     GradientColor gradientColor1;
1105     gradientColor1.SetLinearColor(LinearColor(Color::RED));
1106     gradientColor1.SetDimension(Dimension(0.0));
1107     defaultGradient.AddColor(gradientColor1);
1108     GradientColor gradientColor2;
1109     gradientColor2.SetLinearColor(LinearColor(Color::RED));
1110     gradientColor2.SetDimension(Dimension(1.0));
1111     defaultGradient.AddColor(gradientColor2);
1112     std::vector<GradientColor> defaultGradientColors = defaultGradient.GetColors();
1113 
1114     EXPECT_EQ(defaultGradientColors.size(), gradientColors.size());
1115     EXPECT_EQ(defaultGradientColors[0].GetLinearColor(), gradientColors[0].GetLinearColor());
1116     EXPECT_EQ(defaultGradientColors[1].GetLinearColor(), gradientColors[1].GetLinearColor());
1117     EXPECT_EQ(defaultGradientColors[0].GetDimension(), gradientColors[0].GetDimension());
1118     EXPECT_EQ(defaultGradientColors[1].GetDimension(), gradientColors[1].GetDimension());
1119 }
1120 
1121 /**
1122  * @tc.name: SliderContentModifierTest022
1123  * @tc.desc: TEST slider_content_modifier DrawStep
1124  * direction = HORIZONTAL, blockType = DEFAULT, blockShape = CIRCLE, sliderMode = OUTSET
1125  * @tc.type: FUNC
1126  */
1127 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest022, TestSize.Level1)
1128 {
1129     /**
1130      * @tc.steps: step1. create frameNode and sliderContentModifier.
1131      */
1132     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1133     ASSERT_NE(sliderPattern, nullptr);
1134     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1135     ASSERT_NE(frameNode, nullptr);
1136     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1137     ASSERT_NE(sliderPaintProperty, nullptr);
1138     SliderContentModifier::Parameters parameters;
1139     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
1140     /**
1141      * @tc.steps: step2. Set BackgroundSize call DrawStep function and return.
1142      */
1143     Testing::MockCanvas canvas;
1144     MockCanvasFunction(canvas);
1145     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1146     sliderContentModifier.SetBackgroundSize(POINTF_START, POINTF_START);
1147     sliderContentModifier.SetShowSteps(true);
1148     sliderContentModifier.SetStepRatio(1.1);
1149     auto backStart = sliderContentModifier.backStart_->Get();
1150     auto backEnd = sliderContentModifier.backEnd_->Get();
1151     sliderContentModifier.DrawStep(context);
1152     EXPECT_TRUE(NearEqual(backStart.GetX(), backEnd.GetX()));
1153     EXPECT_TRUE(NearEqual(backStart.GetY(), backEnd.GetY()));
1154     /**
1155      * @tc.steps: step2. call DrawStep function and test stepSize.
1156      */
1157     sliderContentModifier.SetBackgroundSize(POINTF_START, POINTF_END_DIFFX);
1158     sliderContentModifier.SetStepSize(SLIDER_CONTENT_MODIFIER_STEP_SIZE);
1159     sliderContentModifier.SetTrackThickness(SLIDER_CONTENT_MODIFIER_TRACK_THICKNESS_DIFF);
1160     sliderContentModifier.DrawStep(context);
1161     EXPECT_TRUE(NearEqual(backStart.GetX(), backEnd.GetX()));
1162     /**
1163      * @tc.steps: step3. call DrawStep function and test reverse_.
1164      */
1165     sliderContentModifier.SetBackgroundSize(POINTF_START_DIFFY, POINTF_END);
1166     sliderContentModifier.reverse_ = true;
1167     sliderContentModifier.DrawStep(context);
1168     EXPECT_TRUE(NearEqual(backStart.GetY(), backEnd.GetY()));
1169     EXPECT_TRUE(GreatOrEqual(backEnd.GetX(), backStart.GetX()));
1170     EXPECT_TRUE(GreatOrEqual(backEnd.GetY(), backStart.GetX()));
1171 }
1172 
1173 /**
1174  * @tc.name: SliderContentModifierTest023
1175  * @tc.desc: TEST SliderContentModifier DrawDefaultBlock
1176  * @tc.type: FUNC
1177  */
1178 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest023, TestSize.Level1)
1179 {
1180     /**
1181      * @tc.steps: step1. create frameNode and sliderContentModifier.
1182      */
1183     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1184     ASSERT_NE(sliderPattern, nullptr);
1185     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1186     ASSERT_NE(frameNode, nullptr);
1187     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1188     ASSERT_NE(sliderPaintProperty, nullptr);
1189     SliderContentModifier::Parameters parameters;
1190     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
1191     /**
1192      * @tc.steps: step2. set sliderContentModifier attribute and call DrawDefaultBlock function.
1193      */
1194     Testing::MockCanvas canvas;
1195     MockCanvasFunction(canvas);
1196     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1197     sliderContentModifier.DrawDefaultBlock(context);
1198     /**
1199      * @tc.steps: step2. set BlockSize attribute and call DrawDefaultBlock function.
1200      */
1201     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F);
1202     auto blockSize = sliderContentModifier.blockSize_->Get();
1203     float blockRadius = std::min(blockSize.Width(), blockSize.Height()) * HALF;
1204     float radius = blockRadius;
1205     auto borderWidth = sliderContentModifier.blockBorderWidth_->Get();
1206     sliderContentModifier.DrawDefaultBlock(context);
1207     EXPECT_FALSE(GreatOrEqual(borderWidth * HALF, radius));
1208 
1209     /**
1210      * @tc.steps: step2. set BlockBorderWidth attribute and call DrawDefaultBlock function.
1211      */
1212     sliderContentModifier.SetBlockBorderWidth(SLIDER_CONTENT_MODIFIER_BLOCK_BORDER_WIDTH_SMALL);
1213     borderWidth = sliderContentModifier.blockBorderWidth_->Get();
1214     sliderContentModifier.DrawDefaultBlock(context);
1215     EXPECT_TRUE(!NearEqual(borderWidth, .0f));
1216     EXPECT_TRUE(LessNotEqual(borderWidth * HALF, blockRadius));
1217 }
1218 
1219 /**
1220  * @tc.name: SliderContentModifierTest024
1221  * @tc.desc: TEST slider_content_modifier DrawBlockShape
1222  * direction = FREE, blockType = SHAPE, blockShape = ELLIPSE, sliderMode = OUTSET
1223  * @tc.type: FUNC
1224  */
1225 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest024, TestSize.Level1)
1226 {
1227     /**
1228      * @tc.steps: step1. create frameNode and sliderContentModifier.
1229      */
1230     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1231     ASSERT_NE(sliderPattern, nullptr);
1232     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1233     ASSERT_NE(frameNode, nullptr);
1234     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1235     ASSERT_NE(sliderPaintProperty, nullptr);
1236     SliderContentModifier::Parameters parameters;
1237     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
1238     /**
1239      * @tc.steps: step2. don't set anything call DrawBlockShape function return.
1240      */
1241     Testing::MockCanvas canvas;
1242     MockCanvasFunction(canvas);
1243     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1244     sliderContentModifier.DrawBlockShape(context);
1245     EXPECT_EQ(sliderContentModifier.shape_, nullptr);
1246 }
1247 
1248 /**
1249  * @tc.name: SliderContentModifierTest025
1250  * @tc.desc: TEST slider_content_modifier DrawBlockShapeCircle
1251  * direction = HORIZONTAL, blockType = SHAPE, blockShape = CIRCLE, sliderMode = INSET
1252  * @tc.type: FUNC
1253  */
1254 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest025, TestSize.Level1)
1255 {
1256     /**
1257      * @tc.steps: step1. create frameNode and sliderContentModifier.
1258      */
1259     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1260     ASSERT_NE(sliderPattern, nullptr);
1261     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1262     ASSERT_NE(frameNode, nullptr);
1263     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1264     ASSERT_NE(sliderPaintProperty, nullptr);
1265     SliderContentModifier::Parameters parameters;
1266     parameters.selectStart = SELECT_START;
1267     parameters.selectEnd = SELECT_END;
1268     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
1269     /**
1270      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
1271      */
1272     sliderContentModifier.SetDirection(Axis::HORIZONTAL);
1273     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
1274     auto basicShape = AceType::MakeRefPtr<Circle>();
1275     basicShape->SetBasicShapeType(BasicShapeType::CIRCLE);
1276     sliderContentModifier.SetBlockShape(basicShape);
1277     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::INSET);
1278 
1279     Testing::MockCanvas canvas;
1280     MockCanvasFunction(canvas);
1281     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1282     auto circle = AccessibilityManager::DynamicCast<Circle>(sliderContentModifier.shape_);
1283     CHECK_NULL_VOID(circle);
1284 
1285     sliderContentModifier.shapeWidth_->Set(1.0f);
1286     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F);
1287     sliderContentModifier.DrawBlockShapeCircle(context, circle);
1288     EXPECT_FALSE(NearZero(sliderContentModifier.shapeWidth_->Get()));
1289 
1290     sliderContentModifier.shapeHeight_->Set(1.0f);
1291     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F_ZREO);
1292     sliderContentModifier.DrawBlockShapeCircle(context, circle);
1293     EXPECT_FALSE(NearZero(sliderContentModifier.shapeHeight_->Get()));
1294 
1295     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F);
1296     sliderContentModifier.DrawBlockShapeCircle(context, circle);
1297     auto blockSize = sliderContentModifier.blockSize_->Get();
1298     auto scale = std::max(blockSize.Width() / sliderContentModifier.shapeWidth_->Get(),
1299         blockSize.Height() / sliderContentModifier.shapeHeight_->Get());
1300     EXPECT_FALSE(NearZero(scale));
1301 }
1302 
1303 /**
1304  * @tc.name: SliderContentModifierTest026
1305  * @tc.desc: TEST slider_content_modifier DrawBlockShapeEllipse
1306  * direction = HORIZONTAL, blockType = SHAPE, blockShape = Ellipse, sliderMode = INSET
1307  * @tc.type: FUNC
1308  */
1309 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest026, TestSize.Level1)
1310 {
1311     /**
1312      * @tc.steps: step1. create frameNode and sliderContentModifier.
1313      */
1314     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1315     ASSERT_NE(sliderPattern, nullptr);
1316     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1317     ASSERT_NE(frameNode, nullptr);
1318     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1319     ASSERT_NE(sliderPaintProperty, nullptr);
1320     SliderContentModifier::Parameters parameters;
1321     parameters.selectStart = SELECT_START;
1322     parameters.selectEnd = SELECT_END;
1323     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
1324     /**
1325      * @tc.steps: step2. set sliderContentModifier attribute.
1326      */
1327     sliderContentModifier.SetDirection(Axis::HORIZONTAL);
1328     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
1329     auto basicShape = AceType::MakeRefPtr<Ellipse>();
1330     basicShape->SetBasicShapeType(BasicShapeType::ELLIPSE);
1331     sliderContentModifier.SetBlockShape(basicShape);
1332     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::INSET);
1333 
1334     Testing::MockCanvas canvas;
1335     MockCanvasFunction(canvas);
1336     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1337     auto ellipse = AccessibilityManager::DynamicCast<Ellipse>(sliderContentModifier.shape_);
1338     CHECK_NULL_VOID(ellipse);
1339 
1340     sliderContentModifier.shapeWidth_->Set(1.0f);
1341     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F);
1342     sliderContentModifier.DrawBlockShapeEllipse(context, ellipse);
1343     EXPECT_FALSE(NearZero(sliderContentModifier.shapeWidth_->Get()));
1344 
1345     sliderContentModifier.shapeHeight_->Set(1.0f);
1346     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F_ZREO);
1347     sliderContentModifier.DrawBlockShapeEllipse(context, ellipse);
1348     EXPECT_FALSE(NearZero(sliderContentModifier.shapeHeight_->Get()));
1349 
1350     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F);
1351     sliderContentModifier.DrawBlockShapeEllipse(context, ellipse);
1352     auto blockSize = sliderContentModifier.blockSize_->Get();
1353     auto scale = std::max(blockSize.Width() / sliderContentModifier.shapeWidth_->Get(),
1354         blockSize.Height() / sliderContentModifier.shapeHeight_->Get());
1355     EXPECT_FALSE(NearZero(scale));
1356 }
1357 /**
1358  * @tc.name: SliderContentModifierTest027
1359  * @tc.desc: TEST slider_content_modifier DrawBlockShapePath
1360  * direction = HORIZONTAL, blockType = SHAPE, blockShape = CIRCLE, sliderMode = INSET
1361  * @tc.type: FUNC
1362  */
1363 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest027, TestSize.Level1)
1364 {
1365     /**
1366      * @tc.steps: step1. create frameNode and sliderContentModifier.
1367      */
1368     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1369     ASSERT_NE(sliderPattern, nullptr);
1370     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1371     ASSERT_NE(frameNode, nullptr);
1372     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1373     ASSERT_NE(sliderPaintProperty, nullptr);
1374     SliderContentModifier::Parameters parameters;
1375     parameters.selectStart = SELECT_START;
1376     parameters.selectEnd = SELECT_END;
1377     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
1378     /**
1379      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
1380      */
1381     sliderContentModifier.SetDirection(Axis::HORIZONTAL);
1382     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
1383     auto basicShape = AceType::MakeRefPtr<Path>();
1384     basicShape->SetBasicShapeType(BasicShapeType::PATH);
1385     sliderContentModifier.SetBlockShape(basicShape);
1386     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::INSET);
1387 
1388     Testing::MockCanvas canvas;
1389     MockCanvasFunction(canvas);
1390     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1391     auto path = AccessibilityManager::DynamicCast<Path>(sliderContentModifier.shape_);
1392     CHECK_NULL_VOID(path);
1393 
1394     sliderContentModifier.shapeWidth_->Set(1.0f);
1395     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F);
1396     sliderContentModifier.DrawBlockShapePath(context, path);
1397     EXPECT_FALSE(NearZero(sliderContentModifier.shapeWidth_->Get()));
1398 
1399     sliderContentModifier.shapeHeight_->Set(1.0f);
1400     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F_ZREO);
1401     sliderContentModifier.DrawBlockShapePath(context, path);
1402     EXPECT_FALSE(NearZero(sliderContentModifier.shapeHeight_->Get()));
1403 }
1404 /**
1405  * @tc.name: SliderContentModifierTest028
1406  * @tc.desc: TEST slider_content_modifier DrawBlockShapeRect
1407  * direction = HORIZONTAL, blockType = SHAPE, blockShape = CIRCLE, sliderMode = INSET
1408  * @tc.type: FUNC
1409  */
1410 HWTEST_F(SliderModifierTestNg, SliderContentModifierTest028, TestSize.Level1)
1411 {
1412     /**
1413      * @tc.steps: step1. create frameNode and sliderContentModifier.
1414      */
1415     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1416     ASSERT_NE(sliderPattern, nullptr);
1417     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1418     ASSERT_NE(frameNode, nullptr);
1419     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1420     ASSERT_NE(sliderPaintProperty, nullptr);
1421     SliderContentModifier::Parameters parameters;
1422     parameters.selectStart = SELECT_START;
1423     parameters.selectEnd = SELECT_END;
1424     SliderContentModifier sliderContentModifier(parameters, nullptr, nullptr);
1425     /**
1426      * @tc.steps: step2. set sliderContentModifier attribute and call onDraw function.
1427      */
1428     sliderContentModifier.SetDirection(Axis::HORIZONTAL);
1429     sliderContentModifier.SetBlockType(SliderModelNG::BlockStyleType::SHAPE);
1430     auto basicShape = AceType::MakeRefPtr<ShapeRect>();
1431     basicShape->SetBasicShapeType(BasicShapeType::RECT);
1432     sliderContentModifier.SetBlockShape(basicShape);
1433     sliderContentModifier.SetSliderMode(SliderModelNG::SliderMode::INSET);
1434 
1435     Testing::MockCanvas canvas;
1436     MockCanvasFunction(canvas);
1437     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1438     auto rect = AccessibilityManager::DynamicCast<ShapeRect>(sliderContentModifier.shape_);
1439     CHECK_NULL_VOID(rect);
1440 
1441     sliderContentModifier.shapeWidth_->Set(1.0f);
1442     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F);
1443     sliderContentModifier.DrawBlockShapeRect(context, rect);
1444     EXPECT_FALSE(NearZero(sliderContentModifier.shapeWidth_->Get()));
1445 
1446     sliderContentModifier.shapeHeight_->Set(1.0f);
1447     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F_ZREO);
1448     sliderContentModifier.DrawBlockShapeRect(context, rect);
1449     EXPECT_FALSE(NearZero(sliderContentModifier.shapeHeight_->Get()));
1450 
1451     sliderContentModifier.SetBlockSize(BLOCK_SIZE_F);
1452     sliderContentModifier.DrawBlockShapeRect(context, rect);
1453     auto blockSize = sliderContentModifier.blockSize_->Get();
1454     auto scale = std::max(blockSize.Width() / sliderContentModifier.shapeWidth_->Get(),
1455         blockSize.Height() / sliderContentModifier.shapeHeight_->Get());
1456     EXPECT_FALSE(NearZero(scale));
1457 }
1458 
1459 /**
1460  * @tc.name: SliderModelNgTest001
1461  * @tc.desc: TEST SliderModelNG::SetShowTips
1462  * @tc.type: FUNC
1463  */
1464 HWTEST_F(SliderModifierTestNg, SliderModelNgTest001, TestSize.Level1)
1465 {
1466     /**
1467      * @tc.steps: step1. create slider and set the properties ,and then get frameNode.
1468      */
1469     SliderModelNG sliderModelNG;
1470     sliderModelNG.Create(VALUE, STEP, MIN, MAX);
1471     sliderModelNG.SetShowTips(false, std::nullopt);
1472     sliderModelNG.SetBlockSize(BLOCK_SIZE_WIDTH, Dimension(0.0));
1473 
1474     auto frameNode = AceType::DynamicCast<FrameNode>(NG::ViewStackProcessor::GetInstance()->Finish());
1475     ASSERT_NE(frameNode, nullptr);
1476     /**
1477      * @tc.steps: step2. get the properties of all settings.
1478      * @tc.expected: step2. check whether the properties is correct.
1479      */
1480     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1481     ASSERT_NE(sliderPaintProperty, nullptr);
1482     sliderModelNG.SetMinResponsiveDistance(AceType::RawPtr(frameNode), SLIDER_NEGATIVE);
1483     Dimension testResult = sliderModelNG.GetThickness(AceType::RawPtr(frameNode));
1484     EXPECT_EQ(testResult, Dimension(0.0));
1485 }
1486 
1487 /**
1488  * @tc.name: SliderModelNgTest002
1489  * @tc.desc: TEST SliderModelNG::setModel
1490  * @tc.type: FUNC
1491  */
1492 HWTEST_F(SliderModifierTestNg, SliderModelNgTest002, TestSize.Level1)
1493 {
1494     /**
1495      * @tc.steps: step1. create slider and set the properties ,and then get frameNode.
1496      */
1497     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::SLIDER_ETS_TAG, -1, AceType::MakeRefPtr<SliderPattern>());
1498     ASSERT_NE(frameNode, nullptr);
1499     auto sliderLayoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
1500     ASSERT_NE(sliderLayoutProperty, nullptr);
1501     sliderLayoutProperty->UpdateSliderMode(SliderModel::SliderMode::NONE);
1502     SliderModelNG sliderModelNG;
1503     sliderModelNG.Create(VALUE, STEP, MIN, MAX);
1504     sliderModelNG.SetThickness(AceType::RawPtr(frameNode), RADIUS);
1505     sliderModelNG.SetMinResponsiveDistance(AceType::RawPtr(frameNode), 50.0);
1506     /**
1507      * @tc.steps: step2. get the properties of all settings.
1508      * @tc.expected: step2. check whether the properties is correct.
1509      */
1510     auto sliderPaintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
1511     ASSERT_NE(sliderPaintProperty, nullptr);
1512     Dimension testResult = sliderModelNG.GetThickness(AceType::RawPtr(frameNode));
1513     EXPECT_EQ(testResult, RADIUS);
1514 }
1515 
1516 /**
1517  * @tc.name: SliderTipModifierTest002
1518  * @tc.desc: TEST slider_tip_modifier PaintText
1519  * @tc.type: FUNC
1520  */
1521 HWTEST_F(SliderModifierTestNg, SliderTipModifierTest002, TestSize.Level1)
1522 {
1523 /**
1524      * @tc.steps: step1. create frameNode and sliderTipModifier.
1525      */
1526     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1527     ASSERT_NE(sliderPattern, nullptr);
1528     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1529     ASSERT_NE(frameNode, nullptr);
1530     auto sliderLayoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
1531     ASSERT_NE(sliderLayoutProperty, nullptr);
1532     SliderTipModifier sliderTipModifier(
__anond83fed490a02() 1533         [sliderPattern]() { return sliderPattern->GetBubbleVertexPosition(OffsetF(), 0.0f, SizeF()); });
1534     /**
1535      * @tc.steps: step2. set sliderTipModifier's axis is HORIZONTAL and call PaintText function.
1536      * @tc.expected: text's offsetX is equal to half of vertex_'s width.
1537      */
1538     sliderTipModifier.SetSliderGlobalOffset(SLIDER_GLOBAL_OFFSET);
1539     sliderTipModifier.tipFlag_ = AceType::MakeRefPtr<PropertyBool>(true);
1540     Testing::MockCanvas canvas;
1541     MockCanvasFunction(canvas);
1542     DrawingContext context { canvas, SLIDER_WIDTH, SLIDER_HEIGHT };
1543     sliderTipModifier.axis_ = Axis::HORIZONTAL;
1544     sliderTipModifier.isMask_ = true;
1545     auto paragraph = MockParagraph::GetOrCreateMockParagraph();
1546     sliderTipModifier.SetParagraph(paragraph);
1547     sliderTipModifier.PaintTip(context);
1548     SizeF textSize = { 8, 8 };
1549     /**
1550      * @tc.steps: step2. set sliderTipModifier's axis is VERTICAL and call PaintText function.
1551      */
1552     sliderTipModifier.axis_ = Axis::VERTICAL;
1553     sliderTipModifier.isMask_ = true;
1554     sliderTipModifier.PaintText(context);
1555     sliderTipModifier.axis_ = Axis::HORIZONTAL;
1556     sliderTipModifier.PaintText(context);
1557     EXPECT_EQ(sliderTipModifier.textOffset_.GetY(), sliderTipModifier.vertex_.GetY() + textSize.Width() * HALF);
1558 }
1559 
1560 /**
1561  * @tc.name: SliderTipModifierTest003
1562  * @tc.desc: TEST SliderTipModifier::SetTipFlag
1563  * @tc.type: FUNC
1564  */
1565 HWTEST_F(SliderModifierTestNg, SliderTipModifierTest003, TestSize.Level1)
1566 {
1567     /**
1568      * @tc.steps: step1. create frameNode and sliderTipModifier.
1569      */
1570     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1571     ASSERT_NE(sliderPattern, nullptr);
1572     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1573     ASSERT_NE(frameNode, nullptr);
1574     auto sliderLayoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
1575     ASSERT_NE(sliderLayoutProperty, nullptr);
1576     SliderTipModifier sliderTipModifier(
__anond83fed490b02() 1577         [sliderPattern]() { return sliderPattern->GetBubbleVertexPosition(OffsetF(), 0.0f, SizeF()); });
1578     /**
1579      * @tc.steps: step2. set sliderTipModifier's axis is HORIZONTAL and call PaintText function.
1580      * @tc.expected: text's offsetX is equal to half of vertex_'s width.
1581      */
1582     sliderTipModifier.SetSliderGlobalOffset(SLIDER_GLOBAL_OFFSET);
1583     sliderTipModifier.tipFlag_ = AceType::MakeRefPtr<PropertyBool>(true);
1584     sliderTipModifier.SetTipFlag(false);
1585     EXPECT_EQ(sliderTipModifier.tipFlag_, true);
1586 
1587     sliderTipModifier.tipFlag_ = AceType::MakeRefPtr<PropertyBool>(false);
1588     sliderTipModifier.SetTipFlag(true);
1589     EXPECT_EQ(sliderTipModifier.tipFlag_, true);
1590 }
1591 
1592 /**
1593  * @tc.name: SliderTipModifierTest004
1594  * @tc.desc: TEST SliderTipModifier::BuildParagraph
1595  * @tc.type: FUNC
1596  */
1597 HWTEST_F(SliderModifierTestNg, SliderTipModifierTest00, TestSize.Level1)
1598 {
1599     /**
1600      * @tc.steps: step1. create frameNode and sliderTipModifier.
1601      */
1602     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1603     ASSERT_NE(sliderPattern, nullptr);
1604     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1605     ASSERT_NE(frameNode, nullptr);
1606     auto sliderLayoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
1607     ASSERT_NE(sliderLayoutProperty, nullptr);
1608     SliderTipModifier sliderTipModifier(
__anond83fed490c02() 1609         [sliderPattern]() { return sliderPattern->GetBubbleVertexPosition(OffsetF(), 0.0f, SizeF()); });
1610     /**
1611      * @tc.steps: step2. set sliderTipModifier's axis is HORIZONTAL and call PaintText function.
1612      * @tc.expected: text's offsetX is equal to half of vertex_'s width.
1613      */
1614     auto pipeline = MockPipelineContext::GetCurrent();
1615     pipeline->SetFontScale(1.8f);
1616     sliderTipModifier.SetSliderGlobalOffset(SLIDER_GLOBAL_OFFSET);
1617     sliderTipModifier.tipFlag_ = AceType::MakeRefPtr<PropertyBool>(true);
1618     sliderTipModifier.BuildParagraph();
1619     EXPECT_EQ(sliderTipModifier.textFontSize_, SUITABLEAGING_LEVEL_1_TEXT_FONT_SIZE);
1620 
1621     pipeline->SetFontScale(2.5f);
1622     sliderTipModifier.tipFlag_ = AceType::MakeRefPtr<PropertyBool>(false);
1623     sliderTipModifier.BuildParagraph();
1624     EXPECT_EQ(sliderTipModifier.textFontSize_, SUITABLEAGING_LEVEL_2_TEXT_FONT_SIZE);
1625 }
1626 
1627 /**
1628  * @tc.name: SliderTipModifierTest005
1629  * @tc.desc: TEST SliderTipModifier::UpdateBubbleSize
1630  * @tc.type: FUNC
1631  */
1632 HWTEST_F(SliderModifierTestNg, SliderTipModifierTest005, TestSize.Level1)
1633 {
1634     /**
1635      * @tc.steps: step1. create frameNode and sliderTipModifier.
1636      */
1637     RefPtr<SliderPattern> sliderPattern = AceType::MakeRefPtr<SliderPattern>();
1638     ASSERT_NE(sliderPattern, nullptr);
1639     auto frameNode = FrameNode::CreateFrameNode(V2::SLIDER_ETS_TAG, -1, sliderPattern);
1640     ASSERT_NE(frameNode, nullptr);
1641     auto sliderLayoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
1642     ASSERT_NE(sliderLayoutProperty, nullptr);
1643     SliderTipModifier sliderTipModifier(
__anond83fed490d02() 1644         [sliderPattern]() { return sliderPattern->GetBubbleVertexPosition(OffsetF(), 0.0f, SizeF()); });
1645     /**
1646      * @tc.steps: step2. set sliderTipModifier's axis is HORIZONTAL and call PaintText function.
1647      * @tc.expected: text's offsetX is equal to half of vertex_'s width.
1648      */
1649     auto pipeline = MockPipelineContext::GetCurrent();
1650     pipeline->SetFontScale(1.8f);
1651     sliderTipModifier.SetSliderGlobalOffset(SLIDER_GLOBAL_OFFSET);
1652     sliderTipModifier.tipFlag_ = AceType::MakeRefPtr<PropertyBool>(true);
1653     sliderTipModifier.UpdateBubbleSize();
1654     float bubbleSizeHeight = static_cast<float>(BUBBLE_HORIZONTAL_SUITABLEAGING_LEVEL_1_WIDTH.ConvertToPx());
1655     float bubbleSizeWidth = static_cast<float>(BUBBLE_HORIZONTAL_SUITABLEAGING_LEVEL_1_HEIGHT.ConvertToPx());
1656     EXPECT_EQ(sliderTipModifier.bubbleSize_, SizeF(bubbleSizeHeight, bubbleSizeWidth));
1657     sliderTipModifier.axis_ = Axis::VERTICAL;
1658     sliderTipModifier.UpdateBubbleSize();
1659     bubbleSizeHeight = static_cast<float>(BUBBLE_VERTICAL_SUITABLEAGING_LEVEL_1_WIDTH.ConvertToPx());
1660     bubbleSizeWidth = static_cast<float>(BUBBLE_VERTICAL_SUITABLEAGING_LEVEL_1_HEIGHT.ConvertToPx());
1661     EXPECT_EQ(sliderTipModifier.bubbleSize_, SizeF(bubbleSizeHeight, bubbleSizeWidth));
1662 
1663     pipeline->SetFontScale(2.5f);
1664     sliderTipModifier.tipFlag_ = AceType::MakeRefPtr<PropertyBool>(false);
1665     sliderTipModifier.UpdateBubbleSize();
1666     bubbleSizeHeight = static_cast<float>(BUBBLE_VERTICAL_SUITABLEAGING_LEVEL_2_WIDTH.ConvertToPx());
1667     bubbleSizeWidth = static_cast<float>(BUBBLE_VERTICAL_SUITABLEAGING_LEVEL_2_HEIGHT.ConvertToPx());
1668     EXPECT_EQ(sliderTipModifier.bubbleSize_, SizeF(bubbleSizeHeight, bubbleSizeWidth));
1669     sliderTipModifier.axis_ = Axis::HORIZONTAL;
1670     sliderTipModifier.UpdateBubbleSize();
1671     bubbleSizeHeight = static_cast<float>(BUBBLE_HORIZONTAL_SUITABLEAGING_LEVEL_2_WIDTH.ConvertToPx());
1672     bubbleSizeWidth = static_cast<float>(BUBBLE_HORIZONTAL_SUITABLEAGING_LEVEL_2_HEIGHT.ConvertToPx());
1673     EXPECT_EQ(sliderTipModifier.bubbleSize_, SizeF(bubbleSizeHeight, bubbleSizeWidth));
1674 }
1675 
1676 } // namespace OHOS::Ace::NG
1677