1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <optional>
16 #include <string>
17 #include <utility>
18 
19 #include "gtest/gtest.h"
20 
21 // Add the following two macro definitions to test the private and protected method.
22 #define private public
23 #define protected public
24 #include "base/geometry/dimension.h"
25 #include "base/geometry/ng/offset_t.h"
26 #include "base/geometry/ng/size_t.h"
27 #include "base/memory/ace_type.h"
28 #include "core/components/checkable/checkable_component.h"
29 #include "core/components/checkable/checkable_theme.h"
30 #include "core/components_ng/base/frame_node.h"
31 #include "core/components_ng/base/view_stack_processor.h"
32 #include "core/components_ng/pattern/checkbox/checkbox_model.h"
33 #include "core/components_ng/pattern/checkbox/checkbox_model_ng.h"
34 #include "core/components_ng/pattern/checkbox/checkbox_paint_property.h"
35 #include "core/components_ng/pattern/checkbox/checkbox_pattern.h"
36 #include "core/components_ng/pattern/checkboxgroup/checkboxgroup_model_ng.h"
37 #include "core/components_ng/pattern/checkboxgroup/checkboxgroup_paint_method.h"
38 #include "core/components_ng/pattern/checkboxgroup/checkboxgroup_paint_property.h"
39 #include "core/components_ng/pattern/checkboxgroup/checkboxgroup_pattern.h"
40 #include "core/components_ng/pattern/radio/radio_modifier.h"
41 #include "core/components_ng/pattern/stage/page_event_hub.h"
42 #include "core/components_ng/render/drawing_mock.h"
43 #include "test/mock/core/rosen/mock_canvas.h"
44 #include "test/mock/core/common/mock_theme_manager.h"
45 #include "core/components_v2/inspector/inspector_constants.h"
46 #include "core/event/key_event.h"
47 #include "core/event/touch_event.h"
48 #include "core/pipeline/base/render_node.h"
49 #include "core/pipeline_ng/pipeline_context.h"
50 #include "test/mock/core/pipeline/mock_pipeline_context.h"
51 
52 using namespace testing;
53 using namespace testing::ext;
54 namespace OHOS::Ace::NG {
55 namespace {
56 const InspectorFilter filter;
57 const std::string NAME = "checkbox";
58 const std::string GROUP_NAME = "checkboxGroup";
59 const std::string GROUP_NAME_CHANGE = "checkboxGroupChange";
60 const std::string TAG = "CHECKBOX_TAG";
61 const Dimension WIDTH = 50.0_vp;
62 const Dimension HEIGHT = 50.0_vp;
63 const NG::PaddingPropertyF PADDING = NG::PaddingPropertyF();
64 const NG::PaddingProperty newArgs = NG::PaddingProperty();
65 const bool SELECTED = true;
66 const Color SELECTED_COLOR = Color::BLUE;
67 const SizeF CONTENT_SIZE = SizeF(400.0, 500.0);
68 const OffsetF CONTENT_OFFSET = OffsetF(50.0, 60.0);
69 constexpr float COMPONENT_WIDTH = 200.0;
70 constexpr float COMPONENT_HEIGHT = 210.0;
71 constexpr float BORDER_RADIUS = 100.0;
72 constexpr float CHECK_STROKE = 200.0;
73 constexpr float CHECK_MARK_SIZEF = 50.0;
74 constexpr float CHECK_MARK_WIDTHF = 5.0;
75 constexpr float CHECKMARK_PAINTSIZE = 400.0;
76 constexpr float HOVER_DURATION = 250.0;
77 constexpr float HOVER_TO_TOUCH_DURATION = 100.0;
78 constexpr double BORDER_WIDTH = 300.0;
79 constexpr Dimension CHECK_MARK_SIZE = Dimension(CHECK_MARK_SIZEF);
80 constexpr Dimension NEGATIVE_CHECK_MARK_SIZE = Dimension(-CHECK_MARK_SIZEF);
81 constexpr Dimension CHECK_MARK_WIDTH = Dimension(CHECK_MARK_WIDTHF);
82 const Color POINT_COLOR = Color::BLUE;
83 const Color ACTIVE_COLOR = Color::BLACK;
84 const Color INACTIVE_COLOR = Color::GREEN;
85 const Color SHADOW_COLOR = Color::RED;
86 const Color CLICK_EFFECT_COLOR = Color::WHITE;
87 const Color HOVER_COLOR = Color::GRAY;
88 const Color INACTIVE_POINT_COLOR = Color::TRANSPARENT;
89 const Color UNSELECTED_COLOR = Color::RED;
90 const Color CHECK_MARK_COLOR = Color::GREEN;
91 constexpr Dimension HOVER_RADIUS = Dimension(3.0);
92 constexpr Dimension HORIZONTAL_PADDING = Dimension(5.0);
93 constexpr Dimension VERTICAL_PADDING = Dimension(4.0);
94 constexpr Dimension SHADOW_WIDTH_FORUPDATE = Dimension(6.0);
95 constexpr float CHECKBOX_GROUP_LENGTH_ZERO = 0.0f;
96 constexpr Dimension PADDING_SIZE = Dimension(2.0);
97 } // namespace
98 
99 class CheckBoxGroupTestNG : public testing::Test {
100 public:
101     static void SetUpTestCase();
102     static void TearDownTestCase();
103     void SetUp() override;
104     void TearDown() override;
105 };
106 
SetUpTestCase()107 void CheckBoxGroupTestNG::SetUpTestCase()
108 {
109     MockPipelineContext::SetUp();
110     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
111     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
112     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<CheckboxTheme>()));
113     RefPtr<FrameNode> stageNode = AceType::MakeRefPtr<FrameNode>("STAGE", -1, AceType::MakeRefPtr<Pattern>());
114     auto stageManager = AceType::MakeRefPtr<StageManager>(stageNode);
115     MockPipelineContext::GetCurrent()->stageManager_ = stageManager;
116 }
TearDownTestCase()117 void CheckBoxGroupTestNG::TearDownTestCase()
118 {
119     MockPipelineContext::TearDown();
120 }
SetUp()121 void CheckBoxGroupTestNG::SetUp() {}
TearDown()122 void CheckBoxGroupTestNG::TearDown() {}
CheckBoxGroupCreateDefModifierParam()123 CheckBoxGroupModifier::Parameters CheckBoxGroupCreateDefModifierParam()
124 {
125     CheckBoxGroupModifier::Parameters parameters = { BORDER_WIDTH, BORDER_RADIUS, CHECK_STROKE, CHECKMARK_PAINTSIZE,
126         HOVER_DURATION, HOVER_TO_TOUCH_DURATION, POINT_COLOR, ACTIVE_COLOR, INACTIVE_COLOR, SHADOW_COLOR,
127         CLICK_EFFECT_COLOR, HOVER_COLOR, INACTIVE_POINT_COLOR, HOVER_RADIUS, HORIZONTAL_PADDING, VERTICAL_PADDING,
128         SHADOW_WIDTH_FORUPDATE, UIStatus::UNSELECTED, PADDING_SIZE, CheckBoxGroupPaintProperty::SelectStatus::NONE };
129 
130     return parameters;
131 }
132 
133 /**
134  * @tc.name: OnModifyDone001
135  * @tc.desc: Test CheckBoxGroup OnModifyDone001.
136  * @tc.type: FUNC
137  */
138 HWTEST_F(CheckBoxGroupTestNG, OnModifyDone001, TestSize.Level1)
139 {
140     /**
141      * @tc.steps: step1. Init CheckBoxGroup node
142      */
143     CheckBoxGroupModelNG checkBoxGroupModelNG;
144     checkBoxGroupModelNG.Create(std::optional<string>());
145 
146     /**
147      * @tc.steps: step2. call the OnModifyDone function of the checkboxgroup pattern
148      * @tc.expected: the margin property meetings expectations
149      */
150     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
151     ASSERT_NE(frameNode, nullptr);
152     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
153     ASSERT_NE(pattern, nullptr);
154     auto layoutProperty = frameNode->GetLayoutProperty();
155     ASSERT_NE(layoutProperty, nullptr);
156     EXPECT_TRUE(layoutProperty->GetMarginProperty());
157     pattern->OnModifyDone();
158     EXPECT_TRUE(layoutProperty->GetMarginProperty());
159     pattern->OnModifyDone();
160     EXPECT_TRUE(layoutProperty->GetMarginProperty());
161 }
162 
163 /**
164  * @tc.name: UpdateUIStatus001.
165  * @tc.desc: Test CheckBoxGroup UpdateUIStatus001.
166  * @tc.type: FUNC
167  */
168 HWTEST_F(CheckBoxGroupTestNG, UpdateUIStatus001, TestSize.Level1)
169 {
170     /**
171      * @tc.steps: step1. Init CheckBoxGroup node.
172      */
173     CheckBoxGroupModelNG checkBoxGroupModelNG;
174     checkBoxGroupModelNG.Create(std::optional<string>());
175 
176     /**
177      * @tc.steps: step2. call the UpdateUIStatus function of the checkboxgroup pattern.
178      * @tc.expected: the UpdateUIStatus meetings expectations.
179      */
180     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
181     ASSERT_NE(frameNode, nullptr);
182     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
183     ASSERT_NE(pattern, nullptr);
184     auto paintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
185     ASSERT_NE(paintProperty, nullptr);
186     paintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::PART);
187     pattern->UpdateUIStatus(false);
188     EXPECT_EQ(pattern->uiStatus_, UIStatus::PART_TO_OFF);
189     pattern->UpdateUIStatus(true);
190     EXPECT_EQ(pattern->uiStatus_, UIStatus::PART_TO_ON);
191     paintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::ALL);
192     pattern->UpdateUIStatus(false);
193     EXPECT_EQ(pattern->uiStatus_, UIStatus::ON_TO_OFF);
194     pattern->UpdateUIStatus(true);
195     EXPECT_EQ(pattern->uiStatus_, UIStatus::OFF_TO_ON);
196 }
197 
198 /**
199  * @tc.name: OnAfterModifyDone001
200  * @tc.desc: Test CheckBoxGroup OnAfterModifyDone001.
201  * @tc.type: FUNC
202  */
203 HWTEST_F(CheckBoxGroupTestNG, OnAfterModifyDone001, TestSize.Level1)
204 {
205     /**
206      * @tc.steps: step1. Init CheckBoxGroup node.
207      */
208     CheckBoxGroupModelNG checkBoxGroupModelNG;
209     checkBoxGroupModelNG.Create(std::optional<string>());
210 
211     /**
212      * @tc.steps: step2. call the OnAfterModifyDone function of the checkboxgroup pattern.
213      * @tc.expected: the inspectorId property meetings expectations.
214      */
215     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
216     ASSERT_NE(frameNode, nullptr);
217     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
218     ASSERT_NE(pattern, nullptr);
219     pattern->OnAfterModifyDone();
220     auto inspectorId = frameNode->GetInspectorId().value_or("");
221     EXPECT_TRUE(inspectorId.empty());
222     frameNode->UpdateInspectorId("test");
223     pattern->OnAfterModifyDone();
224     EXPECT_FALSE(frameNode->GetInspectorIdValue().empty());
225     auto paintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
226     ASSERT_NE(paintProperty, nullptr);
227     pattern->initSelected_ = true;
228     pattern->OnAfterModifyDone();
229     EXPECT_TRUE(pattern->initSelected_);
230 }
231 
232 /**
233  * @tc.name: UpdateGroupCheckStatus001
234  * @tc.desc: Test CheckBoxGroup UpdateGroupCheckStatus001.
235  * @tc.type: FUNC
236  */
237 HWTEST_F(CheckBoxGroupTestNG, UpdateGroupCheckStatus001, TestSize.Level1)
238 {
239     /**
240      * @tc.steps: step1. Init CheckBoxGroup node.
241      */
242     CheckBoxGroupModelNG checkBoxGroupModelNG;
243     checkBoxGroupModelNG.Create(std::optional<string>());
244 
245     /**
246      * @tc.steps: step2. call the OnAfterModifyDone function of the checkboxgroup pattern.
247      * @tc.expected: the initSelected_ property meetings expectations.
248      */
249     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
250     ASSERT_NE(frameNode, nullptr);
251     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
252     ASSERT_NE(pattern, nullptr);
253     auto paintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
254     ASSERT_NE(paintProperty, nullptr);
255     bool select = true;
256     pattern->UpdateGroupCheckStatus(frameNode, select);
257     select = false;
258     pattern->UpdateGroupCheckStatus(frameNode, select);
259 }
260 
261 /**
262  * @tc.name: InitOnKeyEvent001
263  * @tc.desc: Test checkboxgroup clickCallback of InitOnKeyEvent001.
264  * @tc.type: FUNC
265  */
266 HWTEST_F(CheckBoxGroupTestNG, InitOnKeyEvent001, TestSize.Level1)
267 {
268     CheckBoxGroupModelNG checkBoxGroupModelNG;
269     checkBoxGroupModelNG.Create(std::optional<string>());
270     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
271     EXPECT_NE(frameNode, nullptr);
272     frameNode->MarkModifyDone();
273 
274     auto eventHub = frameNode->GetFocusHub();
275     ASSERT_NE(eventHub, nullptr);
276 
277     /**
278      * test event.action != KeyAction::DOWN
279      */
280     KeyEvent keyEventOne(KeyCode::KEY_A, KeyAction::UP);
281     eventHub->ProcessOnKeyEventInternal(keyEventOne);
282     /**
283      * test event.action == KeyAction::DOWN and event.code != KeyCode::KEY_ENTER
284      */
285     KeyEvent keyEventTwo(KeyCode::KEY_A, KeyAction::DOWN);
286     eventHub->ProcessOnKeyEventInternal(keyEventTwo);
287     /**
288      * test event.action == KeyAction::DOWN and event.code == KeyCode::KEY_ENTER
289      */
290     KeyEvent keyEventThr(KeyCode::KEY_ENTER, KeyAction::DOWN);
291     eventHub->ProcessOnKeyEventInternal(keyEventThr);
292 }
293 
294 /**
295  * @tc.name: CheckBoxGroupPaintPropertyTest001
296  * @tc.desc: Set CheckBoxGroup value into CheckBoxGroupPaintProperty and get it.
297  * @tc.type: FUNC
298  */
299 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintPropertyTest001, TestSize.Level1)
300 {
301     /**
302      * @tc.steps: step1. Init CheckBoxGroup node
303      */
304     CheckBoxGroupModelNG checkBoxGroupModelNG;
305     checkBoxGroupModelNG.Create(std::optional<string>());
306 
307     bool flag = false;
308 
309     /**
310      * @tc.steps: step2. Set parameters to CheckBoxGroup property
311      */
312     checkBoxGroupModelNG.SetSelectAll(SELECTED);
313     checkBoxGroupModelNG.SetSelectedColor(SELECTED_COLOR);
314     checkBoxGroupModelNG.SetWidth(WIDTH);
315     checkBoxGroupModelNG.SetHeight(HEIGHT);
316     checkBoxGroupModelNG.SetPadding(PADDING, newArgs, flag);
317 
318     /**
319      * @tc.steps: step3. Get paint property and get CheckBoxGroup property
320      * @tc.expected: Check the CheckBoxGroup property value
321      */
322     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
323     ASSERT_NE(frameNode, nullptr);
324     auto eventHub = frameNode->GetEventHub<NG::CheckBoxGroupEventHub>();
325     ASSERT_NE(eventHub, nullptr);
326     eventHub->SetGroupName(GROUP_NAME);
327     EXPECT_EQ(eventHub->GetGroupName(), GROUP_NAME);
328     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
329     ASSERT_NE(checkBoxPaintProperty, nullptr);
330     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupSelect(), SELECTED);
331     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupSelectedColor(), SELECTED_COLOR);
332 }
333 
334 /**
335  * @tc.name: CheckBoxGroupPaintPropertyTest002
336  * @tc.desc: Verify ToJsonValue.
337  * @tc.type: FUNC
338  */
339 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintPropertyTest002, TestSize.Level1)
340 {
341     // create mock theme manager
342     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
343     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
344     auto checkboxTheme = AceType::MakeRefPtr<CheckboxTheme>();
345     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme));
346     /**
347      * @tc.steps: step1. Init CheckBoxGroup node
348      */
349     CheckBoxGroupModelNG checkBoxGroupModelNG;
350     checkBoxGroupModelNG.Create(std::optional<string>());
351 
352     bool flag = false;
353 
354     /**
355      * @tc.steps: step2. Set parameters to CheckBoxGroup property
356      */
357     checkBoxGroupModelNG.SetSelectAll(SELECTED);
358     checkBoxGroupModelNG.SetSelectedColor(SELECTED_COLOR);
359     checkBoxGroupModelNG.SetWidth(WIDTH);
360     checkBoxGroupModelNG.SetHeight(HEIGHT);
361     checkBoxGroupModelNG.SetPadding(PADDING, newArgs, flag);
362 
363     /**
364      * @tc.steps: step3. Get paint property and get CheckBoxGroup property
365      * @tc.expected: Check the CheckBoxGroup property value
366      */
367     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
368     ASSERT_NE(frameNode, nullptr);
369     auto eventHub = frameNode->GetEventHub<NG::CheckBoxGroupEventHub>();
370     ASSERT_NE(eventHub, nullptr);
371     eventHub->SetGroupName(GROUP_NAME);
372     EXPECT_EQ(eventHub->GetGroupName(), GROUP_NAME);
373     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
374     ASSERT_NE(checkBoxPaintProperty, nullptr);
375     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupSelect(), SELECTED);
376     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupSelectedColor(), SELECTED_COLOR);
377     auto json = JsonUtil::Create(true);
378     checkBoxPaintProperty->ToJsonValue(json, filter);
379     EXPECT_EQ(json->GetString("selectAll"), "true");
380 }
381 
382 /**
383  * @tc.name: CheckBoxGroupEventTest002
384  * @tc.desc: Test CheckBoxGroup onChange event.
385  * @tc.type: FUNC
386  */
387 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupEventTest002, TestSize.Level1)
388 {
389     /**
390      * @tc.steps: step1. Init CheckBoxGroup node
391      */
392     CheckBoxGroupModelNG checkBoxGroup;
393     checkBoxGroup.Create(GROUP_NAME);
394 
395     /**
396      * @tc.steps: step2. Init change result and onChange function
397      */
398     std::vector<std::string> vec;
399     int status = 0;
400     CheckboxGroupResult groupResult(
401         std::vector<std::string> { NAME }, int(CheckBoxGroupPaintProperty::SelectStatus::ALL));
__anon531cbe9d0202(const BaseEventInfo* groupResult) 402     auto onChange = [&vec, &status](const BaseEventInfo* groupResult) {
403         const auto* eventInfo = TypeInfoHelper::DynamicCast<CheckboxGroupResult>(groupResult);
404         vec = eventInfo->GetNameList();
405         status = eventInfo->GetStatus();
406     };
407 
408     /**
409      * @tc.steps: step3. Get event hub and call UpdateChangeEvent function
410      * @tc.expected: Check the event result value
411      */
412     checkBoxGroup.SetOnChange(onChange);
413     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
414     ASSERT_NE(frameNode, nullptr);
415     auto eventHub = frameNode->GetEventHub<NG::CheckBoxGroupEventHub>();
416     ASSERT_NE(eventHub, nullptr);
417     eventHub->UpdateChangeEvent(&groupResult);
418     EXPECT_FALSE(vec.empty());
419     EXPECT_EQ(vec.front(), NAME);
420     EXPECT_EQ(status, int(CheckBoxGroupPaintProperty::SelectStatus::ALL));
421 }
422 
423 /**
424  * @tc.name: CheckBoxGroupPatternTest003
425  * @tc.desc: Test CheckBoxGroup onModifyDone.
426  * @tc.type: FUNC
427  */
428 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest003, TestSize.Level1)
429 {
430     /**
431      * @tc.steps: step1. Init CheckBoxGroup node
432      */
433     CheckBoxGroupModelNG CheckBoxGroupModelNG;
434     CheckBoxGroupModelNG.Create(GROUP_NAME);
435 
436     /**
437      * @tc.steps: step2. Test CheckBoxGroup onModifyDone method
438      */
439     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
440     ASSERT_NE(frameNode, nullptr);
441     frameNode->MarkModifyDone();
442     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
443     ASSERT_NE(pattern, nullptr);
444     pattern->SetPreGroup(GROUP_NAME);
445     frameNode->MarkModifyDone();
446     pattern->SetPreGroup(GROUP_NAME_CHANGE);
447     frameNode->MarkModifyDone();
448 }
449 
450 /**
451  * @tc.name: CheckBoxGroupMeasureTest004
452  * @tc.desc: Test CheckBoxGroup Measure.
453  * @tc.type: FUNC
454  */
455 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupMeasureTest004, TestSize.Level1)
456 {
457     /**
458      * @tc.steps: step1. Init CheckBoxGroup node
459      */
460     CheckBoxGroupModelNG CheckBoxGroupModelNG;
461     CheckBoxGroupModelNG.Create(GROUP_NAME);
462     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
463     ASSERT_NE(frameNode, nullptr);
464 
465     /**
466      * @tc.steps: step2. Create LayoutWrapperNode and set CheckBoxGroupLayoutAlgorithm.
467      */
468     // Create LayoutWrapperNode and set CheckBoxGroupLayoutAlgorithm.
469     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
470     ASSERT_NE(geometryNode, nullptr);
471     LayoutWrapperNode layoutWrapper = LayoutWrapperNode(frameNode, geometryNode, frameNode->GetLayoutProperty());
472     auto checkBoxGroupPattern = frameNode->GetPattern<CheckBoxGroupPattern>();
473     ASSERT_NE(checkBoxGroupPattern, nullptr);
474     auto checkBoxGroupLayoutAlgorithm = checkBoxGroupPattern->CreateLayoutAlgorithm();
475     ASSERT_NE(checkBoxGroupLayoutAlgorithm, nullptr);
476     layoutWrapper.SetLayoutAlgorithm(AceType::MakeRefPtr<LayoutAlgorithmWrapper>(checkBoxGroupLayoutAlgorithm));
477 
478     /**
479      * @tc.steps: step3. Test CheckBoxGroup Measure method
480      * @tc.expected: Check the CheckBoxGroup frame size and frame offset value
481      */
482     LayoutConstraintF layoutConstraintSize;
483     layoutConstraintSize.selfIdealSize.SetSize(SizeF(WIDTH.ConvertToPx(), HEIGHT.ConvertToPx()));
484     layoutWrapper.GetLayoutProperty()->UpdateLayoutConstraint(layoutConstraintSize);
485     layoutWrapper.GetLayoutProperty()->UpdateContentConstraint();
486     checkBoxGroupLayoutAlgorithm->Measure(&layoutWrapper);
487     // Test the size set by codes.
488     EXPECT_EQ(layoutWrapper.GetGeometryNode()->GetFrameSize(), SizeF(WIDTH.ConvertToPx(), HEIGHT.ConvertToPx()));
489 }
490 
491 /**
492  * @tc.name: CheckBoxGroupPatternTest005
493  * @tc.desc: Test CheckBoxGroup pattern method OnTouchUp.
494  * @tc.type: FUNC
495  */
496 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest005, TestSize.Level1)
497 {
498     /**
499      * @tc.steps: step1. Init CheckBoxGroup node
500      */
501     CheckBoxGroupModelNG CheckBoxGroupModelNG;
502     CheckBoxGroupModelNG.Create(GROUP_NAME);
503 
504     /**
505      * @tc.steps: step2. Get CheckBoxGroup pattern object
506      */
507     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
508     ASSERT_NE(frameNode, nullptr);
509     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
510     ASSERT_NE(pattern, nullptr);
511 
512     /**
513      * @tc.steps: step3. Set CheckBoxGroup pattern variable and call OnTouchUp
514      * @tc.expected: Check the CheckBoxGroup pattern value
515      */
516     pattern->isHover_ = false;
517     pattern->OnTouchUp();
518     EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::NONE);
519     pattern->isHover_ = true;
520     pattern->OnTouchUp();
521     EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::PRESS_TO_HOVER);
522 }
523 
524 /**
525  * @tc.name: CheckBoxGroupPatternTest006
526  * @tc.desc: Test CheckBoxGroup pattern method OnTouchDown.
527  * @tc.type: FUNC
528  */
529 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest006, TestSize.Level1)
530 {
531     /**
532      * @tc.steps: step1. Init CheckBoxGroup node
533      */
534     CheckBoxGroupModelNG CheckBoxGroupModelNG;
535     CheckBoxGroupModelNG.Create(GROUP_NAME);
536 
537     /**
538      * @tc.steps: step2. Get CheckBoxGroup pattern object
539      */
540     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
541     ASSERT_NE(frameNode, nullptr);
542     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
543     ASSERT_NE(pattern, nullptr);
544 
545     /**
546      * @tc.steps: step3. Set CheckBoxGroup pattern variable and call OnTouchDown
547      * @tc.expected: Check the CheckBoxGroup pattern value
548      */
549     pattern->isHover_ = false;
550     pattern->OnTouchDown();
551     EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::PRESS);
552     pattern->isHover_ = true;
553     pattern->OnTouchDown();
554     EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::HOVER_TO_PRESS);
555 }
556 
557 /**
558  * @tc.name: CheckBoxGroupPatternTest007
559  * @tc.desc: Test CheckBoxGroup pattern method OnClick.
560  * @tc.type: FUNC
561  */
562 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest007, TestSize.Level1)
563 {
564     /**
565      * @tc.steps: step1. Init CheckBoxGroup node
566      */
567     CheckBoxGroupModelNG CheckBoxGroupModelNG;
568     CheckBoxGroupModelNG.Create(GROUP_NAME);
569 
570     /**
571      * @tc.steps: step2. Get CheckBoxGroup pattern object
572      */
573     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
574     ASSERT_NE(frameNode, nullptr);
575     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
576     ASSERT_NE(pattern, nullptr);
577 
578     /**
579      * @tc.steps: step3. Set CheckBoxGroup paint property variable and call OnClick
580      * @tc.expected: Check the CheckBoxGroup paint property value
581      */
582     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
583     ASSERT_NE(checkBoxPaintProperty, nullptr);
584     auto eventHub = frameNode->GetEventHub<CheckBoxGroupEventHub>();
585     ASSERT_NE(eventHub, nullptr);
586     auto group = eventHub->GetGroupName();
587     pattern->SetPreGroup(group);
588     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::PART);
589     pattern->OnClick();
590     auto select1 = checkBoxPaintProperty->GetCheckBoxGroupSelect();
591     EXPECT_TRUE(select1.has_value());
592     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::ALL);
593     pattern->OnClick();
594     auto select2 = checkBoxPaintProperty->GetCheckBoxGroupSelect();
595     EXPECT_TRUE(select2.has_value());
596 }
597 
598 /**
599  * @tc.name: CheckBoxGroupPatternTest008
600  * @tc.desc: Test CheckBoxGroup pattern method HandleMouseEvent.
601  * @tc.type: FUNC
602  */
603 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest008, TestSize.Level1)
604 {
605     /**
606      * @tc.steps: step1. Init CheckBoxGroup node
607      */
608     CheckBoxGroupModelNG CheckBoxGroupModelNG;
609     CheckBoxGroupModelNG.Create(GROUP_NAME);
610 
611     /**
612      * @tc.steps: step2. Get CheckBoxGroup pattern object
613      */
614     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
615     ASSERT_NE(frameNode, nullptr);
616     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
617     ASSERT_NE(pattern, nullptr);
618 
619     /**
620      * @tc.steps: step3. Set CheckBoxGroup pattern variable and call HandleMouseEvent
621      * @tc.expected: Check the CheckBoxGroup pattern value
622      */
623     pattern->isHover_ = false;
624     pattern->HandleMouseEvent(true);
625     EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::HOVER);
626     pattern->HandleMouseEvent(false);
627     EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::NONE);
628 }
629 
630 /**
631  * @tc.name: CheckBoxGroupPatternTest009
632  * @tc.desc: Test CheckBoxGroup pattern Init methods.
633  * @tc.type: FUNC
634  */
635 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest009, TestSize.Level1)
636 {
637     /**
638      * @tc.steps: step1. Init CheckBoxGroup node
639      */
640     CheckBoxGroupModelNG CheckBoxGroupModelNG;
641     CheckBoxGroupModelNG.Create(GROUP_NAME);
642 
643     /**
644      * @tc.steps: step2. Get CheckBoxGroup pattern object
645      */
646     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
647     ASSERT_NE(frameNode, nullptr);
648     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
649     ASSERT_NE(pattern, nullptr);
650 
651     /**
652      * @tc.steps: step3. Set CheckBoxGroup pattern variable and call Init methods
653      * @tc.expected: Check the CheckBoxGroup pattern value
654      */
655     // InitMouseEvent()
656     pattern->InitMouseEvent();
657     ASSERT_NE(pattern->mouseEvent_, nullptr);
658     pattern->InitMouseEvent();
659     pattern->mouseEvent_->GetOnHoverEventFunc()(true);
660     // InitTouchEvent()
661     pattern->InitTouchEvent();
662     ASSERT_NE(pattern->touchListener_, nullptr);
663     pattern->InitTouchEvent();
664     TouchEventInfo info("onTouch");
665     TouchLocationInfo touchInfo1(1);
666     touchInfo1.SetTouchType(TouchType::DOWN);
667     info.AddTouchLocationInfo(std::move(touchInfo1));
668     pattern->touchListener_->GetTouchEventCallback()(info);
669     TouchLocationInfo touchInfo2(2);
670     touchInfo2.SetTouchType(TouchType::UP);
671     info.AddTouchLocationInfo(std::move(touchInfo2));
672     pattern->touchListener_->GetTouchEventCallback()(info);
673     TouchLocationInfo touchInfo3(3);
674     touchInfo2.SetTouchType(TouchType::CANCEL);
675     info.AddTouchLocationInfo(std::move(touchInfo3));
676     pattern->touchListener_->GetTouchEventCallback()(info);
677     // InitClickEvent()
678     pattern->InitClickEvent();
679     ASSERT_NE(pattern->clickListener_, nullptr);
680     pattern->InitClickEvent();
681 }
682 
683 /**
684  * @tc.name: CheckBoxGroupPatternTest010
685  * @tc.desc: Test CheckBoxGroup pattern Update methods.
686  * @tc.type: FUNC
687  */
688 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest010, TestSize.Level1)
689 {
690     /**
691      * @tc.steps: step1. Init CheckBoxGroup node
692      */
693     CheckBoxGroupModelNG CheckBoxGroupModelNG;
694     CheckBoxGroupModelNG.Create(GROUP_NAME);
695 
696     /**
697      * @tc.steps: step2. Get CheckBoxGroup pattern object
698      */
699     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
700     ASSERT_NE(frameNode, nullptr);
701     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
702     ASSERT_NE(pattern, nullptr);
703 
704     /**
705      * @tc.steps: step3. Set CheckBoxGroup pattern variable and call Init methods
706      * @tc.expected: Check the CheckBoxGroup pattern value
707      */
708     // UpdateUIStatus(bool check)
709     pattern->uiStatus_ = UIStatus::ON_TO_OFF;
710     pattern->UpdateUIStatus(true);
711     EXPECT_EQ(pattern->uiStatus_, UIStatus::OFF_TO_ON);
712     // UpdateUnSelect()
713     pattern->uiStatus_ = UIStatus::ON_TO_OFF;
714     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
715     ASSERT_NE(checkBoxPaintProperty, nullptr);
716     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::ALL);
717     pattern->UpdateUnSelect();
718     EXPECT_EQ(pattern->uiStatus_, UIStatus::ON_TO_OFF);
719     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::NONE);
720     pattern->UpdateUnSelect();
721     EXPECT_EQ(pattern->uiStatus_, UIStatus::UNSELECTED);
722 }
723 
724 /**
725  * @tc.name: CheckBoxGroupPatternTest011
726  * @tc.desc: Test CheckBoxGroup onModifyDone.
727  * @tc.type: FUNC
728  */
729 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest011, TestSize.Level1)
730 {
731     // create mock theme manager
732     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
733     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
734     auto checkboxTheme = AceType::MakeRefPtr<CheckboxTheme>();
735     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme));
736     CheckBoxGroupModelNG checkBoxGroupModelNG;
737     checkBoxGroupModelNG.Create(GROUP_NAME);
738     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
739     ASSERT_NE(frameNode, nullptr);
740     frameNode->MarkModifyDone();
741     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
742     ASSERT_NE(pattern, nullptr);
743     pattern->SetPreGroup(GROUP_NAME);
744     frameNode->MarkModifyDone();
745     pattern->SetPreGroup(GROUP_NAME_CHANGE);
746     frameNode->MarkModifyDone();
747     ASSERT_NE(pattern, nullptr);
748 }
749 
750 /**
751  * @tc.name: CheckBoxGroupPatternTest012
752  * @tc.desc: Test UpdateCheckBoxStatus.
753  * @tc.type: FUNC
754  */
755 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest012, TestSize.Level1)
756 {
757     /*
758      * @tc.steps: step1. create stageManager.
759      */
760     auto pipelineContext = PipelineContext::GetCurrentContext();
761     RefPtr<FrameNode> stageNode = AceType::MakeRefPtr<FrameNode>("STAGE", -1, AceType::MakeRefPtr<CheckBoxPattern>());
762     auto pageNode = AceType::MakeRefPtr<FrameNode>("STAGE", 0, AceType::MakeRefPtr<CheckBoxPattern>());
763     auto pageEventHub = AceType::MakeRefPtr<NG::PageEventHub>();
764     auto groupManager = pageEventHub->GetGroupManager();
765     pageNode->eventHub_ = pageEventHub;
766     stageNode->AddChild(pageNode);
767     auto stageManager = AceType::MakeRefPtr<StageManager>(stageNode);
768     pipelineContext->stageManager_ = stageManager;
769 
770     CheckBoxModelNG checkBoxModelNG1;
771     checkBoxModelNG1.Create(NAME, GROUP_NAME, TAG);
772     auto frameNode1 = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
773     EXPECT_NE(frameNode1, nullptr);
774     CheckBoxModelNG checkBoxModelNG2;
775     checkBoxModelNG2.Create(NAME, GROUP_NAME, TAG);
776     auto frameNode2 = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
777     EXPECT_NE(frameNode2, nullptr);
778     CheckBoxModelNG checkBoxModelNG3;
779     checkBoxModelNG3.Create(NAME, GROUP_NAME, TAG);
780     auto frameNode3 = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
781     EXPECT_NE(frameNode3, nullptr);
782     CheckBoxGroupModelNG checkBoxGroupModelNG;
783     checkBoxGroupModelNG.Create(GROUP_NAME);
784     auto groupFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
785     EXPECT_NE(groupFrameNode, nullptr);
786     auto pattern = groupFrameNode->GetPattern<CheckBoxGroupPattern>();
787     EXPECT_NE(pattern, nullptr);
788 
789     groupManager->AddCheckBoxToGroup(GROUP_NAME, frameNode1);
790     groupManager->AddCheckBoxToGroup(GROUP_NAME, frameNode2);
791     groupManager->AddCheckBoxToGroup(GROUP_NAME, frameNode3);
792     groupManager->AddCheckBoxGroup(GROUP_NAME, groupFrameNode);
793     bool isSelected = true;
794     pattern->UpdateCheckBoxStatus(groupFrameNode, isSelected);
795     auto checkBoxPaintProperty1 = frameNode1->GetPaintProperty<CheckBoxPaintProperty>();
796     EXPECT_NE(checkBoxPaintProperty1, nullptr);
797     checkBoxPaintProperty1->UpdateCheckBoxSelect(true);
798     auto checkBoxPaintProperty2 = frameNode2->GetPaintProperty<CheckBoxPaintProperty>();
799     EXPECT_NE(checkBoxPaintProperty2, nullptr);
800     checkBoxPaintProperty2->UpdateCheckBoxSelect(false);
801     pattern->UpdateCheckBoxStatus(groupFrameNode, isSelected);
802     isSelected = false;
803     pattern->UpdateCheckBoxStatus(groupFrameNode, isSelected);
804     checkBoxPaintProperty2->UpdateCheckBoxSelect(true);
805     auto checkBoxPaintProperty3 = frameNode3->GetPaintProperty<CheckBoxPaintProperty>();
806     EXPECT_NE(checkBoxPaintProperty3, nullptr);
807     checkBoxPaintProperty3->UpdateCheckBoxSelect(true);
808     isSelected = true;
809     pattern->UpdateCheckBoxStatus(groupFrameNode, isSelected);
810 }
811 
812 /**
813  * @tc.name: CheckBoxGroupPatternTest013
814  * @tc.desc: Test UpdateRepeatedGroupStatus.
815  * @tc.type: FUNC
816  */
817 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest013, TestSize.Level1)
818 {
819     CheckBoxGroupModelNG checkBoxGroupModelNG;
820     checkBoxGroupModelNG.Create(GROUP_NAME);
821     auto groupFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
822     EXPECT_NE(groupFrameNode, nullptr);
823     auto pattern = groupFrameNode->GetPattern<CheckBoxGroupPattern>();
824     EXPECT_NE(pattern, nullptr);
825     bool isSelected = true;
826     pattern->UpdateRepeatedGroupStatus(groupFrameNode, isSelected);
827     auto paintProperty = groupFrameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
828     EXPECT_NE(paintProperty, nullptr);
829     EXPECT_EQ(paintProperty->GetSelectStatus(), CheckBoxGroupPaintProperty::SelectStatus::ALL);
830     isSelected = false;
831     pattern->UpdateRepeatedGroupStatus(groupFrameNode, isSelected);
832     EXPECT_EQ(paintProperty->GetSelectStatus(), CheckBoxGroupPaintProperty::SelectStatus::NONE);
833 }
834 
835 /**
836  * @tc.name: CheckBoxGroupPatternTest014
837  * @tc.desc: Test GetInnerFocusPaintRect.
838  * @tc.type: FUNC
839  */
840 HWTEST_F(CheckBoxGroupTestNG, CheckBoxPatternTest014, TestSize.Level1)
841 {
842     CheckBoxGroupModelNG checkBoxModelNG;
843     checkBoxModelNG.Create(GROUP_NAME);
844     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
845     EXPECT_NE(frameNode, nullptr);
846     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
847     EXPECT_NE(pattern, nullptr);
848     RefPtr<EventHub> eventHub = AccessibilityManager::MakeRefPtr<EventHub>();
849     RefPtr<FocusHub> focusHub = AccessibilityManager::MakeRefPtr<FocusHub>(eventHub, FocusType::DISABLE, false);
850     pattern->InitOnKeyEvent(focusHub);
851     RoundRect paintRect;
852     pattern->GetInnerFocusPaintRect(paintRect);
853 }
854 
855 /**
856  * @tc.name: CheckBoxGroupPatternTest017
857  * @tc.desc: Test SetUnSelectedColor, SetCheckMarkColor, SetCheckMarkSize, SetCheckMarkWidth.
858  * @tc.type: FUNC
859  */
860 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest017, TestSize.Level1)
861 {
862     /**
863      * @tc.steps: step1. Init CheckBoxGroup node
864      */
865     CheckBoxGroupModelNG checkBoxGroupModelNG;
866     checkBoxGroupModelNG.Create(std::optional<string>());
867 
868     /**
869      * @tc.steps: step2. Set parameters to CheckBoxGroup property
870      */
871     Color unselected = Color::BLACK;
872 
873     checkBoxGroupModelNG.SetUnSelectedColor(unselected);
874     checkBoxGroupModelNG.SetCheckMarkColor(unselected);
875     checkBoxGroupModelNG.SetCheckMarkSize(CHECK_MARK_SIZE);
876     checkBoxGroupModelNG.SetCheckMarkWidth(CHECK_MARK_WIDTH);
877 
878     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
879     ASSERT_NE(frameNode, nullptr);
880     auto eventHub = frameNode->GetEventHub<NG::CheckBoxGroupEventHub>();
881     ASSERT_NE(eventHub, nullptr);
882     eventHub->SetGroupName(GROUP_NAME);
883     EXPECT_EQ(eventHub->GetGroupName(), GROUP_NAME);
884     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
885     ASSERT_NE(checkBoxPaintProperty, nullptr);
886     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupUnSelectedColor(), unselected);
887     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupCheckMarkColor(), unselected);
888     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupCheckMarkSize(), CHECK_MARK_SIZE);
889     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupCheckMarkWidth(), CHECK_MARK_WIDTH);
890 }
891 
892 /**
893  * @tc.name: CheckBoxGroupPatternTest017
894  * @tc.desc: Set unSelectedColor into CheckBoxGroupPaintProperty and get it.
895  * @tc.type: FUNC
896  */
897 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest018, TestSize.Level1)
898 {
899     CheckBoxGroupModelNG checkBoxGroupModelNG;
900     checkBoxGroupModelNG.Create(GROUP_NAME);
901     checkBoxGroupModelNG.SetUnSelectedColor(UNSELECTED_COLOR);
902     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
903     ASSERT_NE(frameNode, nullptr);
904     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
905     ASSERT_NE(checkBoxPaintProperty, nullptr);
906     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupUnSelectedColor(), UNSELECTED_COLOR);
907 }
908 
909 /**
910  * @tc.name: CheckBoxGroupPatternTest018
911  * @tc.desc: Set checkMarkColor into CheckBoxGroupPaintProperty and get it.
912  * @tc.type: FUNC
913  */
914 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest019, TestSize.Level1)
915 {
916     CheckBoxGroupModelNG checkBoxGroupModelNG;
917     checkBoxGroupModelNG.Create(GROUP_NAME);
918     checkBoxGroupModelNG.SetCheckMarkColor(CHECK_MARK_COLOR);
919     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
920     ASSERT_NE(frameNode, nullptr);
921     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
922     ASSERT_NE(checkBoxPaintProperty, nullptr);
923     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupCheckMarkColor(), CHECK_MARK_COLOR);
924 }
925 
926 /**
927  * @tc.name: CheckBoxGroupPatternTest019
928  * @tc.desc: Set checkMarkSize into CheckBoxGroupPaintProperty and get it.
929  * @tc.type: FUNC
930  */
931 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest020, TestSize.Level1)
932 {
933     CheckBoxGroupModelNG checkBoxGroupModelNG;
934     checkBoxGroupModelNG.Create(GROUP_NAME);
935     checkBoxGroupModelNG.SetCheckMarkSize(CHECK_MARK_SIZE);
936     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
937     ASSERT_NE(frameNode, nullptr);
938     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
939     ASSERT_NE(checkBoxPaintProperty, nullptr);
940     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupCheckMarkSize(), CHECK_MARK_SIZE);
941 }
942 
943 /**
944  * @tc.name: CheckBoxGroupPatternTest020
945  * @tc.desc: Set checkMarkWidth into CheckBoxGroupPaintProperty and get it.
946  * @tc.type: FUNC
947  */
948 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest021, TestSize.Level1)
949 {
950     CheckBoxGroupModelNG checkBoxGroupModelNG;
951     checkBoxGroupModelNG.Create(GROUP_NAME);
952     checkBoxGroupModelNG.SetCheckMarkWidth(CHECK_MARK_WIDTH);
953     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
954     ASSERT_NE(frameNode, nullptr);
955     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
956     ASSERT_NE(checkBoxPaintProperty, nullptr);
957     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupCheckMarkWidth(), CHECK_MARK_WIDTH);
958 }
959 
960 /**
961  * @tc.name: CheckBoxGroupPaintMethodTest001
962  * @tc.desc: Test CheckBoxGroup Modifier DrawTouchAndHoverBoard.
963  * @tc.type: FUNC
964  */
965 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest001, TestSize.Level1)
966 {
967     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
968     ASSERT_NE(geometryNode, nullptr);
969     geometryNode->SetContentSize(CONTENT_SIZE);
970     geometryNode->SetContentOffset(CONTENT_OFFSET);
971     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
972     ASSERT_NE(checkBoxPaintProperty, nullptr);
973     checkBoxPaintProperty->UpdateCheckBoxGroupSelectedStyle(CheckBoxStyle::SQUARE_STYLE);
974     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
975     /**
976      *  @tc.case: case. When isTouch is true, CheckBoxGroupModifier will call DrawTouchBoard.
977      */
978     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
979     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
980     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
981     auto modifier_ = checkBoxPaintMethod.GetContentModifier(&paintWrapper);
982     ASSERT_NE(modifier_, nullptr);
983     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
984     Testing::MockCanvas canvas;
985     SizeF size;
986     OffsetF offset;
987     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
988     EXPECT_CALL(canvas, DrawRoundRect(_)).Times(1);
989     checkBoxGroupModifier_->DrawTouchAndHoverBoard(canvas, size, offset);
990 }
991 
992 /**
993  * @tc.name: CheckBoxGroupPaintMethodTest004
994  * @tc.desc: Test CheckBoxGroup Modifier paintCheckBox when enabled_ == false..
995  * @tc.type: FUNC
996  */
997 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest004, TestSize.Level1)
998 {
999     /**
1000      * @tc.case: case1. When uiStatus_ == UIStatus::OFF_TO_ON and enabled_ == false.
1001      */
1002     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1003     ASSERT_NE(geometryNode, nullptr);
1004     geometryNode->SetContentSize(CONTENT_SIZE);
1005     geometryNode->SetContentOffset(CONTENT_OFFSET);
1006     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
1007     ASSERT_NE(checkBoxPaintProperty, nullptr);
1008     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
1009     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1010     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1011     checkBoxGroupModifier_->uiStatus_ = AceType::MakeRefPtr<PropertyInt>(static_cast<int>(UIStatus::OFF_TO_ON));
1012     checkBoxGroupModifier_->enabled_ = AceType::MakeRefPtr<PropertyBool>(false);
1013     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
1014     auto modifier_ = checkBoxPaintMethod.GetContentModifier(&paintWrapper);
1015     ASSERT_NE(modifier_, nullptr);
1016     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1017     Testing::MockCanvas canvas;
1018     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1019     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1020     DrawingContext context { canvas, COMPONENT_WIDTH, COMPONENT_HEIGHT };
1021     checkBoxGroupModifier_->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1022 }
1023 
1024 /**
1025  * @tc.name: CheckBoxGroupPaintMethodTest005
1026  * @tc.desc: Test CheckBoxGroup Modifier will paintCheckBox when UIStatus is ON_TO_OFF.
1027  * @tc.type: FUNC
1028  */
1029 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest005, TestSize.Level1)
1030 {
1031     /**
1032      * @tc.case: case1. When uiStatus_ == UIStatus::ON_TO_OFF and enabled_ == true.
1033      */
1034     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1035     ASSERT_NE(geometryNode, nullptr);
1036     geometryNode->SetContentSize(CONTENT_SIZE);
1037     geometryNode->SetContentOffset(CONTENT_OFFSET);
1038     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
1039     ASSERT_NE(checkBoxPaintProperty, nullptr);
1040     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
1041     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1042     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1043     checkBoxGroupModifier_->uiStatus_ = AceType::MakeRefPtr<PropertyInt>(static_cast<int>(UIStatus::ON_TO_OFF));
1044     checkBoxGroupModifier_->enabled_ = AceType::MakeRefPtr<PropertyBool>(true);
1045     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
1046     auto modifier_ = checkBoxPaintMethod.GetContentModifier(&paintWrapper);
1047     ASSERT_NE(modifier_, nullptr);
1048     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1049     Testing::MockCanvas canvas;
1050     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1051     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1052     DrawingContext context { canvas, COMPONENT_WIDTH, COMPONENT_HEIGHT };
1053     checkBoxGroupModifier_->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1054 }
1055 
1056 /**
1057  * @tc.name: CheckBoxGroupPaintMethodTest006
1058  * @tc.desc: Test CheckBoxGroup  Modifier will paintCheckBox when UIStatus is UNSELECTED.
1059  * @tc.type: FUNC
1060  */
1061 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest006, TestSize.Level1)
1062 {
1063     /**
1064      * @tc.case: case1. When uiStatus_ == UIStatus::UNSELECTED and enabled_ == true.
1065      */
1066     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1067     ASSERT_NE(geometryNode, nullptr);
1068     geometryNode->SetContentSize(CONTENT_SIZE);
1069     geometryNode->SetContentOffset(CONTENT_OFFSET);
1070     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
1071     ASSERT_NE(checkBoxPaintProperty, nullptr);
1072     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
1073     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1074     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1075     checkBoxGroupModifier_->uiStatus_ = AceType::MakeRefPtr<PropertyInt>(static_cast<int>(UIStatus::UNSELECTED));
1076     checkBoxGroupModifier_->enabled_ = AceType::MakeRefPtr<PropertyBool>(true);
1077     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
1078     auto modifier_ = checkBoxPaintMethod.GetContentModifier(&paintWrapper);
1079     ASSERT_NE(modifier_, nullptr);
1080     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1081     Testing::MockCanvas canvas;
1082     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1083     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1084     DrawingContext context { canvas, COMPONENT_WIDTH, COMPONENT_HEIGHT };
1085     checkBoxGroupModifier_->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1086 }
1087 
1088 /**
1089  * @tc.name: CheckBoxGroupPaintMethodTest007
1090  * @tc.desc: Test CheckBoxGroup Modifier PaintCheckBox PaintCheckBoxGroupPartStatus.
1091  * @tc.type: FUNC
1092  */
1093 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest007, TestSize.Level1)
1094 {
1095     /**
1096      * @tc.case: case1. When status == CheckBoxGroupPaintProperty::SelectStatus::PART and enabled_ == true.
1097      */
1098     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1099     ASSERT_NE(geometryNode, nullptr);
1100     geometryNode->SetContentSize(CONTENT_SIZE);
1101     geometryNode->SetContentOffset(CONTENT_OFFSET);
1102     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
1103     ASSERT_NE(checkBoxPaintProperty, nullptr);
1104     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::PART);
1105     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
1106     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1107     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1108     checkBoxGroupModifier_->status_ =
1109         AceType::MakeRefPtr<PropertyInt>(static_cast<int>(CheckBoxGroupPaintProperty::SelectStatus::PART));
1110     checkBoxGroupModifier_->enabled_ = AceType::MakeRefPtr<PropertyBool>(true);
1111     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
1112     auto modifier_ = checkBoxPaintMethod.GetContentModifier(&paintWrapper);
1113     ASSERT_NE(modifier_, nullptr);
1114     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1115     Testing::MockCanvas canvas;
1116     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1117     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1118     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
1119     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
1120     DrawingContext context { canvas, COMPONENT_WIDTH, COMPONENT_HEIGHT };
1121     checkBoxGroupModifier_->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1122 }
1123 
1124 /**
1125  * @tc.name: CheckBoxGroupPaintMethodTest008
1126  * @tc.desc: Test CheckBoxGroup Modifier  paintCheckBox when UIStatus is PART_TO_OFF.
1127  * @tc.type: FUNC
1128  */
1129 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest008, TestSize.Level1)
1130 {
1131     /**
1132      * @tc.case: case1. When uiStatus_ == UIStatus::PART_TO_OFF and enabled_ == false.
1133      */
1134     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1135     ASSERT_NE(geometryNode, nullptr);
1136     geometryNode->SetContentSize(CONTENT_SIZE);
1137     geometryNode->SetContentOffset(CONTENT_OFFSET);
1138     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
1139     ASSERT_NE(checkBoxPaintProperty, nullptr);
1140     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
1141     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1142     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1143     checkBoxGroupModifier_->uiStatus_ = AceType::MakeRefPtr<PropertyInt>(static_cast<int>(UIStatus::PART_TO_OFF));
1144     checkBoxGroupModifier_->enabled_ = AceType::MakeRefPtr<PropertyBool>(false);
1145     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
1146     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1147     Testing::MockCanvas canvas;
1148     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1149     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1150     DrawingContext context { canvas, COMPONENT_WIDTH, COMPONENT_HEIGHT };
1151     checkBoxGroupModifier_->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1152 }
1153 
1154 /**
1155  * @tc.name: CheckBoxGroupPaintMethodTest009
1156  * @tc.desc: Test checkBoxPaintMethod  UpdateContentModifier.
1157  * @tc.type: FUNC
1158  */
1159 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest009, TestSize.Level1)
1160 {
1161     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1162     ASSERT_NE(geometryNode, nullptr);
1163     geometryNode->SetContentSize(SizeF(COMPONENT_WIDTH, COMPONENT_WIDTH));
1164     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
1165     ASSERT_NE(checkBoxPaintProperty, nullptr);
1166     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
1167     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1168     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1169     checkBoxGroupModifier_->uiStatus_ = AceType::MakeRefPtr<PropertyInt>(static_cast<int>(UIStatus::FOCUS));
1170     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
1171     checkBoxPaintProperty->UpdateCheckBoxGroupSelectedColor(ACTIVE_COLOR);
1172     checkBoxPaintProperty->UpdateCheckBoxGroupUnSelectedColor(INACTIVE_COLOR);
1173     checkBoxPaintProperty->UpdateCheckBoxGroupCheckMarkColor(POINT_COLOR);
1174     checkBoxPaintProperty->UpdateCheckBoxGroupCheckMarkSize(NEGATIVE_CHECK_MARK_SIZE);
1175     checkBoxPaintProperty->UpdateCheckBoxGroupCheckMarkWidth(CHECK_MARK_WIDTH);
1176     /**
1177      * @tc.expected: step1. Check the CheckBoxGroup property value.
1178      */
1179     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1180     EXPECT_EQ(checkBoxGroupModifier_->activeColor_->Get(), LinearColor(ACTIVE_COLOR));
1181     EXPECT_EQ(checkBoxGroupModifier_->inactiveColor_->Get(), LinearColor(INACTIVE_COLOR));
1182     EXPECT_EQ(checkBoxGroupModifier_->pointColor_->Get(), LinearColor(POINT_COLOR));
1183     EXPECT_EQ(checkBoxGroupModifier_->checkMarkPaintSize_->Get(), COMPONENT_WIDTH);
1184     EXPECT_EQ(checkBoxGroupModifier_->checkStroke_->Get(), CHECK_MARK_WIDTHF);
1185     /**
1186      * @tc.expected: step2.Test GetCheckBoxGroupCheckMarkSizeValue().ConvertToPx() >= 0.
1187      */
1188     checkBoxPaintProperty->UpdateCheckBoxGroupCheckMarkSize(CHECK_MARK_SIZE);
1189     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1190     EXPECT_EQ(checkBoxGroupModifier_->checkMarkPaintSize_->Get(), CHECK_MARK_SIZEF);
1191 }
1192 
1193 /**
1194  * @tc.name: CheckBoxGroupPaintMethodTest010
1195  * @tc.desc: Test CheckBoxGroupPattern UpdateModifierParam.
1196  * @tc.type: FUNC
1197  */
1198 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest010, TestSize.Level1)
1199 {
1200     const std::optional<std::string> groupName;
1201     CheckBoxGroupModelNG checkboxGroupModel;
1202     checkboxGroupModel.Create(groupName);
1203     auto groupFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1204     ASSERT_NE(groupFrameNode, nullptr);
1205     auto checkBoxPaintProperty = groupFrameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
1206     ASSERT_NE(checkBoxPaintProperty, nullptr);
1207     checkBoxPaintProperty->UpdateCheckBoxGroupSelectedColor(ACTIVE_COLOR);
1208     checkBoxPaintProperty->UpdateCheckBoxGroupUnSelectedColor(INACTIVE_COLOR);
1209     checkBoxPaintProperty->UpdateCheckBoxGroupCheckMarkColor(POINT_COLOR);
1210     checkBoxPaintProperty->UpdateCheckBoxGroupCheckMarkSize(CHECK_MARK_SIZE);
1211     checkBoxPaintProperty->UpdateCheckBoxGroupCheckMarkWidth(CHECK_MARK_WIDTH);
1212     auto pattern = groupFrameNode->GetPattern<CheckBoxGroupPattern>();
1213     ASSERT_NE(pattern, nullptr);
1214     auto paintMethod = pattern->CreateNodePaintMethod();
1215     ASSERT_NE(paintMethod, nullptr);
1216     auto modifier_ = pattern->checkBoxGroupModifier_;
1217     ASSERT_NE(modifier_, nullptr);
1218     EXPECT_EQ(modifier_->activeColor_->Get(), LinearColor(ACTIVE_COLOR));
1219     EXPECT_EQ(modifier_->inactiveColor_->Get(), LinearColor(INACTIVE_COLOR));
1220     EXPECT_EQ(modifier_->pointColor_->Get(), LinearColor(POINT_COLOR));
1221     EXPECT_EQ(modifier_->checkMarkPaintSize_->Get(), CHECK_MARK_SIZEF);
1222     EXPECT_EQ(modifier_->checkStroke_->Get(), CHECK_MARK_WIDTHF);
1223 }
1224 
1225 /**
1226  * @tc.name: CheckBoxGroupPaintMethodTest011
1227  * @tc.desc:  Test CheckBoxGroupModifier  paintCheckBox when enabled_ == false.
1228  * @tc.type: FUNC
1229  */
1230 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest011, TestSize.Level1)
1231 {
1232     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1233     ASSERT_NE(geometryNode, nullptr);
1234     geometryNode->SetContentSize(CONTENT_SIZE);
1235     geometryNode->SetContentOffset(CONTENT_OFFSET);
1236     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
1237     ASSERT_NE(checkBoxPaintProperty, nullptr);
1238     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
1239     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1240     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1241     checkBoxGroupModifier_->uiStatus_ = AceType::MakeRefPtr<PropertyInt>(static_cast<int>(UIStatus::ON_TO_OFF));
1242     checkBoxGroupModifier_->enabled_ = AceType::MakeRefPtr<PropertyBool>(false);
1243     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
1244     auto modifier_ = checkBoxPaintMethod.GetContentModifier(&paintWrapper);
1245     ASSERT_NE(modifier_, nullptr);
1246     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1247     Testing::MockCanvas canvas;
1248     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1249     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1250     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
1251     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
1252     DrawingContext context { canvas, COMPONENT_WIDTH, COMPONENT_HEIGHT };
1253     checkBoxGroupModifier_->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1254 }
1255 
1256 /**
1257  * @tc.name: CheckBoxGroupPaintMethodTest012
1258  * @tc.desc:  Test CheckBoxGroupModifier PaintCheckBox when enabled_ == false.
1259  * @tc.type: FUNC
1260  */
1261 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest012, TestSize.Level1)
1262 {
1263     RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1264     ASSERT_NE(geometryNode, nullptr);
1265     geometryNode->SetContentSize(CONTENT_SIZE);
1266     geometryNode->SetContentOffset(CONTENT_OFFSET);
1267     auto checkBoxPaintProperty = AceType::MakeRefPtr<CheckBoxGroupPaintProperty>();
1268     ASSERT_NE(checkBoxPaintProperty, nullptr);
1269     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::PART);
1270     PaintWrapper paintWrapper(nullptr, geometryNode, checkBoxPaintProperty);
1271     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1272     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1273     checkBoxGroupModifier_->uiStatus_ = AceType::MakeRefPtr<PropertyInt>(static_cast<int>(UIStatus::UNSELECTED));
1274     checkBoxGroupModifier_->enabled_ = AceType::MakeRefPtr<PropertyBool>(false);
1275     CheckBoxGroupPaintMethod checkBoxPaintMethod(checkBoxGroupModifier_);
1276     auto modifier_ = checkBoxPaintMethod.GetContentModifier(&paintWrapper);
1277     ASSERT_NE(modifier_, nullptr);
1278     checkBoxPaintMethod.UpdateContentModifier(&paintWrapper);
1279     Testing::MockCanvas canvas;
1280     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1281     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1282     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
1283     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
1284     DrawingContext context { canvas, COMPONENT_WIDTH, COMPONENT_HEIGHT };
1285     checkBoxGroupModifier_->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1286 }
1287 
1288 /**
1289  * @tc.name: CheckBoxGroupPaintMethodTest013
1290  * @tc.desc: Test CheckBoxGroup UpdateAnimatableProperty and SetBoardColor.
1291  * @tc.type: FUNC
1292  */
1293 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintMethodTest013, TestSize.Level1)
1294 {
1295     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1296     auto checkBoxGroupModifier_ = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1297     checkBoxGroupModifier_->hoverColor_ = Color::RED;
1298     checkBoxGroupModifier_->clickEffectColor_ = Color::BLUE;
1299     checkBoxGroupModifier_->touchHoverType_ = TouchHoverAnimationType::HOVER;
1300     checkBoxGroupModifier_->UpdateAnimatableProperty();
1301     checkBoxGroupModifier_->animateTouchHoverColor_ =
1302         AceType::MakeRefPtr<AnimatablePropertyColor>(LinearColor(Color::TRANSPARENT));
1303     checkBoxGroupModifier_->touchHoverType_ = TouchHoverAnimationType::PRESS_TO_HOVER;
1304     checkBoxGroupModifier_->UpdateAnimatableProperty();
1305     EXPECT_EQ(checkBoxGroupModifier_->animateTouchHoverColor_->Get(), LinearColor(Color::RED));
1306     checkBoxGroupModifier_->touchHoverType_ = TouchHoverAnimationType::NONE;
1307     checkBoxGroupModifier_->UpdateAnimatableProperty();
1308     EXPECT_EQ(checkBoxGroupModifier_->animateTouchHoverColor_->Get(), LinearColor(Color::RED.BlendOpacity(0)));
1309     checkBoxGroupModifier_->touchHoverType_ = TouchHoverAnimationType::HOVER_TO_PRESS;
1310     checkBoxGroupModifier_->UpdateAnimatableProperty();
1311     EXPECT_EQ(checkBoxGroupModifier_->animateTouchHoverColor_->Get(), LinearColor(Color::BLUE));
1312     checkBoxGroupModifier_->touchHoverType_ = TouchHoverAnimationType::PRESS;
1313     checkBoxGroupModifier_->UpdateAnimatableProperty();
1314     EXPECT_EQ(checkBoxGroupModifier_->animateTouchHoverColor_->Get(), LinearColor(Color::BLUE));
1315 }
1316 
1317 /**
1318  * @tc.name: CheckBoxGroupAccessibilityPropertyTestNg001
1319  * @tc.desc: Test Text property of CheckBoxGroup.
1320  * @tc.type: FUNC
1321  */
1322 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupAccessibilityPropertyTestNg001, TestSize.Level1)
1323 {
1324     CheckBoxGroupModelNG checkBoxGroupModelNG;
1325     checkBoxGroupModelNG.Create(std::optional<string>());
1326 
1327     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1328     ASSERT_NE(frameNode, nullptr);
1329 
1330     auto eventHub = frameNode->GetEventHub<NG::CheckBoxGroupEventHub>();
1331     ASSERT_NE(eventHub, nullptr);
1332     eventHub->SetGroupName(GROUP_NAME);
1333 
1334     auto accessibility = frameNode->GetAccessibilityProperty<CheckBoxGroupAccessibilityProperty>();
1335     ASSERT_NE(accessibility, nullptr);
1336     EXPECT_EQ(accessibility->GetText(), GROUP_NAME);
1337 }
1338 
1339 /**
1340  * @tc.name: CheckBoxGroupAccessibilityPropertyTestNg002
1341  * @tc.desc: Test IsCheckable and IsChecked properties of CheckBoxGroup.
1342  * @tc.type: FUNC
1343  */
1344 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupAccessibilityPropertyTestNg002, TestSize.Level1)
1345 {
1346     CheckBoxGroupModelNG checkBoxGroupModelNG;
1347     checkBoxGroupModelNG.Create(std::optional<string>());
1348 
1349     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1350     ASSERT_NE(frameNode, nullptr);
1351     auto accessibility = frameNode->GetAccessibilityProperty<CheckBoxGroupAccessibilityProperty>();
1352     ASSERT_NE(accessibility, nullptr);
1353     EXPECT_TRUE(accessibility->IsCheckable());
1354 
1355     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
1356     ASSERT_NE(checkBoxPaintProperty, nullptr);
1357     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::ALL);
1358     EXPECT_TRUE(accessibility->IsChecked());
1359     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::PART);
1360     EXPECT_FALSE(accessibility->IsChecked());
1361     checkBoxPaintProperty->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::NONE);
1362     EXPECT_FALSE(accessibility->IsChecked());
1363 }
1364 
1365 /**
1366  * @tc.name: CheckBoxGroupAccessibilityPropertyTestNg003
1367  * @tc.desc: Test GetCollectionItemCounts property of CheckBoxGroup.
1368  * @tc.type: FUNC
1369  */
1370 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupAccessibilityPropertyTestNg003, TestSize.Level1)
1371 {
1372     auto groupFrameNode = FrameNode::GetOrCreateFrameNode(
__anon531cbe9d0302() 1373         V2::CHECKBOXGROUP_ETS_TAG, 1, []() { return AceType::MakeRefPtr<CheckBoxGroupPattern>(); });
1374     EXPECT_NE(groupFrameNode, nullptr);
1375     auto eventHub = groupFrameNode->GetEventHub<NG::CheckBoxGroupEventHub>();
1376     eventHub->SetGroupName(GROUP_NAME);
1377     groupFrameNode->MarkModifyDone();
1378 
1379     auto accessibility = groupFrameNode->GetAccessibilityProperty<CheckBoxGroupAccessibilityProperty>();
1380     ASSERT_NE(accessibility, nullptr);
1381     EXPECT_EQ(accessibility->GetCollectionItemCounts(), 0);
1382 }
1383 
1384 /**
1385  * @tc.name: CheckBoxUpdateChangeEventTest001
1386  * @tc.desc: Test CheckBoxGroup onChange event.
1387  * @tc.type: FUNC
1388  */
1389 HWTEST_F(CheckBoxGroupTestNG, CheckBoxUpdateChangeEventTest001, TestSize.Level1)
1390 {
1391     CheckBoxGroupModelNG checkBoxGroup;
1392     checkBoxGroup.Create(GROUP_NAME);
1393     std::vector<std::string> vec;
1394     int status = 0;
1395     CheckboxGroupResult groupResult(
1396         std::vector<std::string> { NAME }, int(CheckBoxGroupPaintProperty::SelectStatus::ALL));
__anon531cbe9d0402(const BaseEventInfo* groupResult) 1397     auto changeEvent = [&vec, &status](const BaseEventInfo* groupResult) {
1398         const auto* eventInfo = TypeInfoHelper::DynamicCast<CheckboxGroupResult>(groupResult);
1399         vec = eventInfo->GetNameList();
1400         status = eventInfo->GetStatus();
1401     };
1402 
1403     checkBoxGroup.SetChangeEvent(changeEvent);
1404     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1405     ASSERT_NE(frameNode, nullptr);
1406     auto eventHub = frameNode->GetEventHub<NG::CheckBoxGroupEventHub>();
1407     ASSERT_NE(eventHub, nullptr);
1408     eventHub->UpdateChangeEvent(&groupResult);
1409     EXPECT_FALSE(vec.empty());
1410     EXPECT_EQ(vec.front(), NAME);
1411     EXPECT_EQ(status, int(CheckBoxGroupPaintProperty::SelectStatus::ALL));
1412 }
1413 
1414 /**
1415  * @tc.name: CheckBoxGroupModifierTest001
1416  * @tc.desc: Test CheckBoxGroupModifier PaintCheckBox method in different situation.
1417  * @tc.type: FUNC
1418  */
1419 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupModifierTest001, TestSize.Level1)
1420 {
1421     /**
1422      * @tc.steps: step1. Create CheckBoxGroupModifier.
1423      * @tc.expected: Create successfully.
1424      */
1425     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1426     auto checkBoxGroupModifier = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1427     ASSERT_NE(checkBoxGroupModifier, nullptr);
1428     Testing::MockCanvas canvas;
1429     DrawingContext context { canvas, COMPONENT_WIDTH, COMPONENT_HEIGHT };
1430 
1431     /**
1432      * @tc.steps: step2. Call PaintCheckBox method.
1433      * @tc.expected: Call method successfully.
1434      */
1435     checkBoxGroupModifier->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::PART);
1436     checkBoxGroupModifier->SetEnabled(false);
1437     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO);
1438     checkBoxGroupModifier->SetCheckStroke(CHECKBOX_GROUP_LENGTH_ZERO);
1439     EXPECT_CALL(canvas, AttachPen(_)).WillRepeatedly(ReturnRef(canvas));
1440     EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
1441     EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
1442     EXPECT_CALL(canvas, DetachPen()).WillRepeatedly(ReturnRef(canvas));
1443     checkBoxGroupModifier->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1444     checkBoxGroupModifier->SetSelectStatus(CheckBoxGroupPaintProperty::SelectStatus::ALL);
1445     checkBoxGroupModifier->SetUiStatus(UIStatus::OFF_TO_ON);
1446     checkBoxGroupModifier->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1447     checkBoxGroupModifier->SetEnabled(true);
1448     checkBoxGroupModifier->SetUiStatus(UIStatus::PART_TO_ON);
1449     checkBoxGroupModifier->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1450     checkBoxGroupModifier->SetEnabled(false);
1451     checkBoxGroupModifier->SetUiStatus(UIStatus::ON_TO_OFF);
1452     checkBoxGroupModifier->PaintCheckBox(context, CONTENT_OFFSET, CONTENT_SIZE);
1453 }
1454 
1455 /**
1456  * @tc.name: CheckBoxGroupModifierTest002
1457  * @tc.desc: Test CheckBoxGroupModifier DrawCheck method in different situation.
1458  * @tc.type: FUNC
1459  */
1460 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupModifierTest002, TestSize.Level1)
1461 {
1462     /**
1463      * @tc.steps: step1. Create CheckBoxGroupModifier.
1464      * @tc.expected: Create successfully.
1465      */
1466     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1467     auto checkBoxGroupModifier = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1468     ASSERT_NE(checkBoxGroupModifier, nullptr);
1469 
1470     /**
1471      * @tc.steps: step2. Call DrawCheck method.
1472      * @tc.expected: Call successfully once while checkMarkPaintSize_ and checkStroke_ both equal to 0.
1473      */
1474     Testing::MockCanvas canvas;
1475     RSPen rsPen;
1476     RSPen shadowPen;
1477     EXPECT_CALL(canvas, AttachPen(_)).Times(2).WillRepeatedly(ReturnRef(canvas));
1478     EXPECT_CALL(canvas, DrawPath(_)).Times(2);
1479     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO);
1480     checkBoxGroupModifier->SetCheckStroke(CHECKBOX_GROUP_LENGTH_ZERO);
1481     checkBoxGroupModifier->DrawCheck(canvas, CONTENT_OFFSET, rsPen, shadowPen, CONTENT_SIZE);
1482     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO + 1.0);
1483     checkBoxGroupModifier->DrawCheck(canvas, CONTENT_OFFSET, rsPen, shadowPen, CONTENT_SIZE);
1484     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO);
1485     checkBoxGroupModifier->SetCheckStroke(CHECKBOX_GROUP_LENGTH_ZERO + 1);
1486     checkBoxGroupModifier->DrawCheck(canvas, CONTENT_OFFSET, rsPen, shadowPen, CONTENT_SIZE);
1487     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO + 1.0);
1488     checkBoxGroupModifier->DrawCheck(canvas, CONTENT_OFFSET, rsPen, shadowPen, CONTENT_SIZE);
1489 }
1490 
1491 /**
1492  * @tc.name: CheckBoxGroupModifierTest003
1493  * @tc.desc: Test CheckBoxGroupModifier DrawPart method in different situation.
1494  * @tc.type: FUNC
1495  */
1496 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupModifierTest003, TestSize.Level1)
1497 {
1498     /**
1499      * @tc.steps: step1. Create CheckBoxGroupModifier.
1500      * @tc.expected: Create successfully.
1501      */
1502     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1503     auto checkBoxGroupModifier = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
1504     ASSERT_NE(checkBoxGroupModifier, nullptr);
1505 
1506     /**
1507      * @tc.steps: step2. Call DrawPart method.
1508      * @tc.expected: Call successfully once while checkMarkPaintSize_ and checkStroke_ both equal to 0.
1509      */
1510     Testing::MockCanvas canvas;
1511     RSPen rsPen;
1512     EXPECT_CALL(canvas, AttachPen(_)).Times(2).WillRepeatedly(ReturnRef(canvas));
1513     EXPECT_CALL(canvas, DrawPath(_)).Times(2);
1514     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO);
1515     checkBoxGroupModifier->SetCheckStroke(CHECKBOX_GROUP_LENGTH_ZERO);
1516     checkBoxGroupModifier->DrawPart(canvas, CONTENT_OFFSET, rsPen, CONTENT_SIZE);
1517     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO + 1.0);
1518     checkBoxGroupModifier->DrawPart(canvas, CONTENT_OFFSET, rsPen, CONTENT_SIZE);
1519     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO);
1520     checkBoxGroupModifier->SetCheckStroke(CHECKBOX_GROUP_LENGTH_ZERO + 1);
1521     checkBoxGroupModifier->DrawPart(canvas, CONTENT_OFFSET, rsPen, CONTENT_SIZE);
1522     checkBoxGroupModifier->SetCheckMarkPaintSize(CHECKBOX_GROUP_LENGTH_ZERO + 1.0);
1523     checkBoxGroupModifier->DrawPart(canvas, CONTENT_OFFSET, rsPen, CONTENT_SIZE);
1524 }
1525 
1526 /**
1527  * @tc.name: CheckBoxGroupLayoutAlgorithmTest001
1528  * @tc.desc: Test CheckBoxGroupLayoutAlgorithm MeasureContent.
1529  * @tc.type: FUNC
1530  */
1531 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupLayoutAlgorithmTest001, TestSize.Level1)
1532 {
1533     /**
1534      * @tc.steps: step1. Create CheckBoxGroupLayoutAlgorithm.
1535      * @tc.expected: Create successfully.
1536      */
1537     std::optional<float> nullLength;
1538     OptionalSizeF optionalSizeF(nullLength, nullLength);
1539     LayoutConstraintF contentConstraint;
1540     contentConstraint.selfIdealSize = optionalSizeF;
1541     LayoutWrapperNode layoutWrapper =
1542         LayoutWrapperNode(nullptr, nullptr, AccessibilityManager::MakeRefPtr<LayoutProperty>());
1543     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1544     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1545     auto checkboxTheme = AceType::MakeRefPtr<CheckboxTheme>();
1546     checkboxTheme->defaultWidth_ = Dimension(COMPONENT_WIDTH);
1547     checkboxTheme->defaultHeight_ = Dimension(COMPONENT_WIDTH);
1548     checkboxTheme->hotZoneHorizontalPadding_ = Dimension(COMPONENT_WIDTH / 4);
1549     checkboxTheme->hotZoneVerticalPadding_ = Dimension(COMPONENT_WIDTH / 4);
1550     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme));
1551     auto checkBoxGroupLayoutAlgorithm = AceType::MakeRefPtr<CheckBoxGroupLayoutAlgorithm>();
1552     ASSERT_NE(checkBoxGroupLayoutAlgorithm, nullptr);
1553 
1554     /**
1555      * @tc.steps: step2. Call method wile the width and height of contentConstraint are both null.
1556      * @tc.expected: Return sizeF base on default width and height.
1557      */
1558     auto size = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper);
1559     EXPECT_FLOAT_EQ(size->Width(), COMPONENT_WIDTH / 2);
1560     EXPECT_FLOAT_EQ(size->Height(), COMPONENT_WIDTH / 2);
1561     checkboxTheme->defaultHeight_ = Dimension(COMPONENT_HEIGHT);
1562     size = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper);
1563     EXPECT_FLOAT_EQ(size->Width(), COMPONENT_WIDTH / 2);
1564     EXPECT_FLOAT_EQ(size->Height(), COMPONENT_WIDTH / 2);
1565 
1566     /**
1567      * @tc.steps: step3. Call method wile the width of contentConstraint is null.
1568      * @tc.expected: Return sizeF base on height of contentConstraint.
1569      */
1570     contentConstraint.selfIdealSize.SetHeight(std::make_optional<float>(-1));
1571     size = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper);
1572     EXPECT_FLOAT_EQ(size->Width(), COMPONENT_WIDTH / 2);
1573     EXPECT_FLOAT_EQ(size->Height(), COMPONENT_WIDTH / 2);
1574     contentConstraint.selfIdealSize.SetHeight(BORDER_RADIUS);
1575     size = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper);
1576     EXPECT_FLOAT_EQ(size->Width(), BORDER_RADIUS);
1577     EXPECT_FLOAT_EQ(size->Height(), BORDER_RADIUS);
1578 
1579     /**
1580      * @tc.steps: step4. Call method wile the height of contentConstraint is null.
1581      * @tc.expected: Return sizeF base on width of contentConstraint.
1582      */
1583     contentConstraint.selfIdealSize.SetWidth(std::make_optional<float>(-1));
1584     contentConstraint.selfIdealSize.SetHeight(nullLength);
1585     size = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper);
1586     EXPECT_FLOAT_EQ(size->Width(), COMPONENT_WIDTH / 2);
1587     EXPECT_FLOAT_EQ(size->Height(), COMPONENT_WIDTH / 2);
1588     contentConstraint.selfIdealSize.SetWidth(BORDER_WIDTH);
1589     size = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper);
1590     EXPECT_FLOAT_EQ(size->Width(), BORDER_WIDTH);
1591     EXPECT_FLOAT_EQ(size->Height(), BORDER_WIDTH);
1592 
1593     /**
1594      * @tc.steps: step5. Call method wile contentConstraint is totally available.
1595      * @tc.expected: Return sizeF base on the width and height of contentConstraint.
1596      */
1597     contentConstraint.selfIdealSize.SetWidth(std::make_optional<float>(-1));
1598     contentConstraint.selfIdealSize.SetHeight(std::make_optional<float>(-1));
1599     size = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper);
1600     EXPECT_FLOAT_EQ(size->Width(), COMPONENT_WIDTH / 2);
1601     EXPECT_FLOAT_EQ(size->Height(), COMPONENT_WIDTH / 2);
1602     contentConstraint.selfIdealSize.SetWidth(BORDER_WIDTH);
1603     contentConstraint.selfIdealSize.SetHeight(BORDER_RADIUS);
1604     size = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper);
1605     EXPECT_FLOAT_EQ(size->Width(), BORDER_RADIUS);
1606     EXPECT_FLOAT_EQ(size->Height(), BORDER_RADIUS);
1607 }
1608 
1609 /**
1610  * @tc.name: CheckBoxGroupPatternTest022
1611  * @tc.desc: Test CheckBoxGroupPattern MeasureContent.
1612  * @tc.type: FUNC
1613  */
1614 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest022, TestSize.Level1)
1615 {
1616     /**
1617      * @tc.steps: step1. Create CheckBoxGroupPattern.
1618      * @tc.expected: Create successfully.
1619      */
1620     CheckBoxGroupModelNG CheckBoxGroupModelNG;
1621     CheckBoxGroupModelNG.Create(GROUP_NAME);
1622     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1623     ASSERT_NE(frameNode, nullptr);
1624     auto checkBoxGroupPattern = frameNode->GetPattern<CheckBoxGroupPattern>();
1625     ASSERT_NE(checkBoxGroupPattern, nullptr);
1626 
1627     /**
1628      * @tc.steps: step2. Call touchCallback with different touchType.
1629      * @tc.expected: TouchCallback works correctly.
1630      */
1631     auto touchCallback = checkBoxGroupPattern->touchListener_->GetTouchEventCallback();
1632     TouchLocationInfo touchLocationInfo(-1);
1633     touchLocationInfo.SetTouchType(TouchType::UP);
1634     TouchEventInfo touchEventInfo(NAME);
1635     touchEventInfo.touches_.clear();
1636     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
1637     touchCallback(touchEventInfo);
1638     EXPECT_EQ(checkBoxGroupPattern->touchHoverType_, TouchHoverAnimationType::NONE);
1639     touchLocationInfo.SetTouchType(TouchType::CANCEL);
1640     checkBoxGroupPattern->isHover_ = true;
1641     touchCallback(touchEventInfo);
1642     EXPECT_EQ(checkBoxGroupPattern->touchHoverType_, TouchHoverAnimationType::PRESS_TO_HOVER);
1643 }
1644 
1645 /**
1646  * @tc.name: CheckBoxGroupPatternTest023
1647  * @tc.desc: Test CheckBoxGroupPattern UpdateState.
1648  * @tc.type: FUNC
1649  */
1650 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest023, TestSize.Level1)
1651 {
1652     /**
1653      * @tc.steps: step1. Create CheckBoxGroupPattern.
1654      * @tc.expected: Create successfully.
1655      */
1656     CheckBoxGroupModelNG CheckBoxGroupModelNG;
1657     CheckBoxGroupModelNG.Create(GROUP_NAME);
1658     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1659     ASSERT_NE(frameNode, nullptr);
1660     auto paintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
1661     ASSERT_NE(paintProperty, nullptr);
1662     auto eventHub = frameNode->GetEventHub<CheckBoxGroupEventHub>();
1663     ASSERT_NE(eventHub, nullptr);
1664     auto checkBoxGroupPattern = frameNode->GetPattern<CheckBoxGroupPattern>();
1665     ASSERT_NE(checkBoxGroupPattern, nullptr);
1666 
1667     /**
1668      * @tc.steps: step2. Call method while checkBoxGroup hasn't preGroup.
1669      * @tc.expected: SelectStatus and uiStatus set correctly.
1670      */
1671     checkBoxGroupPattern->preGroup_.reset();
1672     paintProperty->UpdateCheckBoxGroupSelect(true);
1673     checkBoxGroupPattern->isFirstCreated_ = false;
1674     checkBoxGroupPattern->UpdateState();
1675     EXPECT_EQ(paintProperty->GetSelectStatus(), CheckBoxGroupPaintProperty::SelectStatus::ALL);
1676     EXPECT_EQ(checkBoxGroupPattern->uiStatus_, UIStatus::OFF_TO_ON);
1677 
1678     /**
1679      * @tc.steps: step3. Call method while clicked requires processing.
1680      * @tc.expected: Change selectAll to false dynamically.
1681      */
1682     checkBoxGroupPattern->preGroup_ = std::make_optional<std::string>(NAME);
1683     eventHub->SetGroupName(NAME);
1684     checkBoxGroupPattern->updateFlag_ = true;
1685     checkBoxGroupPattern->SetIsAddToMap(true);
1686     checkBoxGroupPattern->UpdateState();
1687     EXPECT_EQ(paintProperty->GetSelectStatus(), CheckBoxGroupPaintProperty::SelectStatus::ALL);
1688     EXPECT_FALSE(checkBoxGroupPattern->updateFlag_);
1689     paintProperty->UpdateCheckBoxGroupSelect(true);
1690     checkBoxGroupPattern->SetIsAddToMap(false);
1691     checkBoxGroupPattern->UpdateState();
1692     EXPECT_EQ(paintProperty->GetSelectStatus(), CheckBoxGroupPaintProperty::SelectStatus::ALL);
1693     EXPECT_FALSE(checkBoxGroupPattern->updateFlag_);
1694 
1695     paintProperty->UpdateCheckBoxGroupSelect(false);
1696     checkBoxGroupPattern->UpdateState();
1697     EXPECT_FALSE(checkBoxGroupPattern->updateFlag_);
1698 }
1699 
1700 /**
1701  * @tc.name: CheckBoxGroupPatternTest024
1702  * @tc.desc: Test CheckBoxGroupPattern UpdateCheckBoxStatus.
1703  * @tc.type: FUNC
1704  */
1705 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest024, TestSize.Level1)
1706 {
1707     /*
1708      * @tc.steps: step1. create stageManager.
1709      */
1710     auto pipelineContext = PipelineContext::GetCurrentContext();
1711     RefPtr<FrameNode> stageNode = AceType::MakeRefPtr<FrameNode>("STAGE", -1, AceType::MakeRefPtr<CheckBoxPattern>());
1712     auto pageNode = AceType::MakeRefPtr<FrameNode>("STAGE", 0, AceType::MakeRefPtr<CheckBoxPattern>());
1713     auto pageEventHub = AceType::MakeRefPtr<NG::PageEventHub>();
1714     auto groupManager = pageEventHub->GetGroupManager();
1715     pageNode->eventHub_ = pageEventHub;
1716     stageNode->AddChild(pageNode);
1717     auto stageManager = AceType::MakeRefPtr<StageManager>(stageNode);
1718     pipelineContext->stageManager_ = stageManager;
1719     /**
1720      * @tc.steps: step1. Create CheckBoxGroupPattern.
1721      * @tc.expected: Create successfully.
1722      */
1723     CheckBoxGroupModelNG CheckBoxGroupModelNG;
1724     CheckBoxGroupModelNG.Create(GROUP_NAME);
1725     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1726     ASSERT_NE(frameNode, nullptr);
1727     auto checkBoxGroupPattern = frameNode->GetPattern<CheckBoxGroupPattern>();
1728     ASSERT_NE(checkBoxGroupPattern, nullptr);
1729 
1730     /**
1731      * @tc.steps: step2. Create frameNode list as parameter and call method.
1732      * @tc.expected: Unavailable frameNode is skipped.
1733      */
1734     auto group = NAME;
1735     std::list<WeakPtr<FrameNode>> list;
1736     Ace::RefPtr<FrameNode> frameNode1 = nullptr;
1737     auto frameNode2 = FrameNode::GetOrCreateFrameNode(
__anon531cbe9d0502() 1738         V2::CHECKBOXGROUP_ETS_TAG, 1, []() { return AceType::MakeRefPtr<CheckBoxGroupPattern>(); });
1739     auto frameNode3 = FrameNode::GetOrCreateFrameNode(
__anon531cbe9d0602() 1740         V2::CHECK_BOX_ETS_TAG, 2, []() { return AceType::MakeRefPtr<CheckBoxPattern>(); });
1741     auto paintProperty = frameNode3->GetPaintProperty<CheckBoxPaintProperty>();
1742     ASSERT_NE(paintProperty, nullptr);
1743     paintProperty->ResetCheckBoxSelect();
1744     auto checkBoxPattern = frameNode3->GetPattern<CheckBoxPattern>();
1745     ASSERT_NE(checkBoxPattern, nullptr);
1746     checkBoxPattern->SetLastSelect(true);
1747     groupManager->AddCheckBoxGroup(GROUP_NAME, frameNode1);
1748     groupManager->AddCheckBoxGroup(GROUP_NAME, frameNode2);
1749     groupManager->AddCheckBoxGroup(GROUP_NAME, frameNode3);
1750     checkBoxGroupPattern->UpdateCheckBoxStatus(frameNode, false);
1751     EXPECT_TRUE(checkBoxPattern->lastSelect_);
1752 }
1753 
1754 /**
1755  * @tc.name: CheckBoxGroupPatternTest025
1756  * @tc.desc: Test CheckBoxGroupPattern InitOnKeyEvent.
1757  * @tc.type: FUNC
1758  */
1759 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest025, TestSize.Level1)
1760 {
1761     /**
1762      * @tc.steps: step1. Create CheckBoxGroupPattern.
1763      * @tc.expected: Create successfully.
1764      */
1765     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1766     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1767     auto checkboxTheme = AceType::MakeRefPtr<CheckboxTheme>();
1768     checkboxTheme->focusRadius_ = Dimension(BORDER_RADIUS);
1769     checkboxTheme->focusPaintPadding_ = Dimension(COMPONENT_WIDTH);
1770     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme));
1771     CheckBoxGroupModelNG CheckBoxGroupModelNG;
1772     CheckBoxGroupModelNG.Create(GROUP_NAME);
1773     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1774     ASSERT_NE(frameNode, nullptr);
1775     auto checkBoxGroupPattern = frameNode->GetPattern<CheckBoxGroupPattern>();
1776     ASSERT_NE(checkBoxGroupPattern, nullptr);
1777 
1778     /**
1779      * @tc.steps: step2. Get onKeyEventCallback and getInnerPaintRectCallback.
1780      * @tc.expected: Get successfully.
1781      */
1782     RefPtr<EventHub> eventHub = AccessibilityManager::MakeRefPtr<EventHub>();
1783     RefPtr<FocusHub> focusHub = AccessibilityManager::MakeRefPtr<FocusHub>(eventHub, FocusType::DISABLE, false);
1784     checkBoxGroupPattern->InitOnKeyEvent(focusHub);
1785     auto getInnerPaintRectCallback = focusHub->getInnerFocusRectFunc_;
1786 
1787     /**
1788      * @tc.steps: step3. Test onKeyEventCallback and getInnerPaintRectCallback.
1789      * @tc.expected: Callbacks works correctly.
1790      */
1791     KeyEvent keyEvent(KeyCode::KEY_FOCUS, KeyAction::CLICK);
1792     EXPECT_FALSE(focusHub->ProcessOnKeyEventInternal(keyEvent));
1793     keyEvent.action = KeyAction::DOWN;
1794     EXPECT_FALSE(focusHub->ProcessOnKeyEventInternal(keyEvent));
1795     keyEvent.code = KeyCode::KEY_ENTER;
1796     EXPECT_FALSE(focusHub->ProcessOnKeyEventInternal(keyEvent));
1797 
1798     checkBoxGroupPattern->offset_ = OffsetF(COMPONENT_HEIGHT, COMPONENT_HEIGHT);
1799     checkBoxGroupPattern->size_ = SizeF(BORDER_RADIUS, BORDER_RADIUS);
1800     RoundRect paintRect;
1801     getInnerPaintRectCallback(paintRect);
1802     EXPECT_FLOAT_EQ(paintRect.GetRect().GetX(), COMPONENT_HEIGHT - COMPONENT_WIDTH);
1803     EXPECT_FLOAT_EQ(paintRect.GetRect().GetY(), COMPONENT_HEIGHT - COMPONENT_WIDTH);
1804     EXPECT_FLOAT_EQ(paintRect.GetRect().Width(), BORDER_RADIUS + COMPONENT_WIDTH * 2);
1805     EXPECT_FLOAT_EQ(paintRect.GetRect().Height(), BORDER_RADIUS + COMPONENT_WIDTH * 2);
1806     EXPECT_FLOAT_EQ(paintRect.GetCornerRadius(RoundRect::CornerPos::TOP_LEFT_POS).x, BORDER_RADIUS);
1807     EXPECT_FLOAT_EQ(paintRect.GetCornerRadius(RoundRect::CornerPos::TOP_LEFT_POS).y, BORDER_RADIUS);
1808     EXPECT_FLOAT_EQ(paintRect.GetCornerRadius(RoundRect::CornerPos::TOP_RIGHT_POS).x, BORDER_RADIUS);
1809     EXPECT_FLOAT_EQ(paintRect.GetCornerRadius(RoundRect::CornerPos::TOP_RIGHT_POS).y, BORDER_RADIUS);
1810     EXPECT_FLOAT_EQ(paintRect.GetCornerRadius(RoundRect::CornerPos::BOTTOM_LEFT_POS).x, BORDER_RADIUS);
1811     EXPECT_FLOAT_EQ(paintRect.GetCornerRadius(RoundRect::CornerPos::BOTTOM_LEFT_POS).y, BORDER_RADIUS);
1812     EXPECT_FLOAT_EQ(paintRect.GetCornerRadius(RoundRect::CornerPos::BOTTOM_RIGHT_POS).x, BORDER_RADIUS);
1813     EXPECT_FLOAT_EQ(paintRect.GetCornerRadius(RoundRect::CornerPos::BOTTOM_RIGHT_POS).y, BORDER_RADIUS);
1814 }
1815 
1816 /**
1817  * @tc.name: OnColorConfigurationUpdate001
1818  * @tc.desc: Test on color configuration update.
1819  * @tc.type: FUNC
1820  */
1821 HWTEST_F(CheckBoxGroupTestNG, OnColorConfigurationUpdate001, TestSize.Level1)
1822 {
1823     CheckBoxGroupModelNG CheckBoxGroupModelNG;
1824     CheckBoxGroupModelNG.Create(GROUP_NAME);
1825     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1826     ASSERT_NE(frameNode, nullptr);
1827     auto checkBoxGroupPattern = frameNode->GetPattern<CheckBoxGroupPattern>();
1828     ASSERT_NE(checkBoxGroupPattern, nullptr);
1829     auto pipeline = PipelineBase::GetCurrentContext();
1830     ASSERT_NE(pipeline, nullptr);
1831     auto checkBoxTheme = pipeline->GetTheme<CheckboxTheme>();
1832     ASSERT_NE(checkBoxTheme, nullptr);
1833     checkBoxTheme->activeColor_ = Color::BLACK;
1834     checkBoxTheme->inactiveColor_ = Color::BLACK;
1835     checkBoxTheme->pointColor_ = Color::BLACK;
1836     checkBoxGroupPattern->OnColorConfigurationUpdate();
1837     auto checkBoxGroupPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
1838     ASSERT_NE(checkBoxGroupPaintProperty, nullptr);
1839     EXPECT_EQ(checkBoxGroupPaintProperty->GetCheckBoxGroupSelectedColor(), Color::BLACK);
1840     EXPECT_EQ(checkBoxGroupPaintProperty->GetCheckBoxGroupUnSelectedColor(), Color::BLACK);
1841     EXPECT_EQ(checkBoxGroupPaintProperty->GetCheckBoxGroupCheckMarkColor(), Color::BLACK);
1842 }
1843 
1844 /**
1845  * @tc.name: CheckBoxGroupPatternTest026
1846  * @tc.desc: Test CheckBoxGroupPattern UpdateModifierParam.
1847  * @tc.type: FUNC
1848  */
1849 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest026, TestSize.Level1)
1850 {
1851     /**
1852      * @tc.steps: step1. Create CheckBoxGroupPattern.
1853      * @tc.expected: Create successfully.
1854      */
1855     CheckBoxGroupModelNG CheckBoxGroupModelNG;
1856     CheckBoxGroupModelNG.Create(GROUP_NAME);
1857     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1858     ASSERT_NE(frameNode, nullptr);
1859     auto paintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
1860     ASSERT_NE(paintProperty, nullptr);
1861     auto geometryNode = frameNode->GetGeometryNode();
1862     ASSERT_NE(geometryNode, nullptr);
1863     auto checkBoxGroupPattern = frameNode->GetPattern<CheckBoxGroupPattern>();
1864     ASSERT_NE(checkBoxGroupPattern, nullptr);
1865 
1866     /**
1867      * @tc.steps: step2. Call method while properties are unavailable.
1868      * @tc.expected: ModifierParam isn't updated.
1869      */
1870     paintProperty->ResetCheckBoxGroupSelectedColor();
1871     paintProperty->ResetCheckBoxGroupUnSelectedColor();
1872     paintProperty->ResetCheckBoxGroupCheckMarkColor();
1873     paintProperty->ResetCheckBoxGroupCheckMarkSize();
1874     paintProperty->ResetCheckBoxGroupCheckMarkWidth();
1875     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1876     checkBoxGroupPattern->UpdateModifierParam(parameters);
1877     paintProperty->UpdateCheckBoxGroupCheckMarkSize(Dimension(-1.0));
1878     geometryNode->SetContentSize(SizeF(COMPONENT_WIDTH, COMPONENT_HEIGHT));
1879     checkBoxGroupPattern->UpdateModifierParam(parameters);
1880     EXPECT_FLOAT_EQ(parameters.checkMarkPaintSize, COMPONENT_WIDTH);
1881 }
1882 
1883 /**
1884  * @tc.name: CheckBoxGroupPatternTest027
1885  * @tc.desc: CheckBoxGroup test Select and ClearSelection.
1886  */
1887 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest027, TestSize.Level1)
1888 {
1889     CheckBoxGroupModelNG checkBoxGroupModelNG;
1890     checkBoxGroupModelNG.Create(GROUP_NAME);
1891     checkBoxGroupModelNG.SetSelectAll(true);
1892     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1893     ASSERT_NE(frameNode, nullptr);
1894     auto pattern = frameNode->GetPattern<CheckBoxGroupPattern>();
1895     ASSERT_NE(pattern, nullptr);
1896     pattern->updateFlag_ = false;
1897     pattern->SetAccessibilityAction();
1898 
1899     auto accessibilityProperty = frameNode->GetAccessibilityProperty<CheckBoxGroupAccessibilityProperty>();
1900     ASSERT_NE(accessibilityProperty, nullptr);
1901     EXPECT_TRUE(accessibilityProperty->ActActionSelect());
1902 
1903     bool isSelected = true;
1904     pattern->updateFlag_ = false;
1905     pattern->MarkIsSelected(isSelected);
1906     EXPECT_TRUE(accessibilityProperty->ActActionClearSelection());
1907 }
1908 
1909 /**
1910  * @tc.name: CheckBoxGroupPaintPropertyTest028
1911  * @tc.desc: Set CheckBoxGroup style value into CheckBoxGroupPaintProperty and get it.
1912  * @tc.type: FUNC
1913  */
1914 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintPropertyTest028, TestSize.Level1)
1915 {
1916     /**
1917      * @tc.steps: step1. Init CheckBoxGroup node
1918      */
1919     int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
1920     CheckBoxGroupModelNG checkBoxGroupModelNG;
1921     checkBoxGroupModelNG.Create(std::optional<string>());
1922 
1923     /**
1924      * @tc.steps: step2. Set parameters to CheckBoxGroup property
1925      */
1926     checkBoxGroupModelNG.SetCheckboxGroupStyle(CheckBoxStyle::SQUARE_STYLE);
1927     /**
1928      * @tc.steps: step3. Get paint property and get CheckBoxGroup property
1929      * @tc.expected: Check the CheckBoxGroup property value
1930      */
1931     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1932     ASSERT_NE(frameNode, nullptr);
1933     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
1934     ASSERT_NE(checkBoxPaintProperty, nullptr);
1935     EXPECT_EQ(checkBoxPaintProperty->HasCheckBoxGroupSelectedStyle(), true);
1936     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxGroupSelectedStyleValue(), CheckBoxStyle::SQUARE_STYLE);
1937     AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
1938 }
1939 
1940 /**
1941  * @tc.name: CheckBoxGroupPaintPropertyTest029
1942  * @tc.desc: Verify ToJsonValue of shape.
1943  * @tc.type: FUNC
1944  */
1945 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPaintPropertyTest029, TestSize.Level1)
1946 {
1947     int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
1948     AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_TWELVE));
1949     /**
1950      * @tc.steps: step1. Init CheckBoxGroup node
1951      */
1952     CheckBoxGroupModelNG checkBoxGroupModelNG;
1953     checkBoxGroupModelNG.Create(std::optional<string>());
1954 
1955     /**
1956      * @tc.steps: step2. Set parameters to CheckBoxGroup property
1957      */
1958     checkBoxGroupModelNG.SetCheckboxGroupStyle(CheckBoxStyle::SQUARE_STYLE);
1959     /**
1960      * @tc.steps: step3. Get paint property and get CheckBoxGroup property
1961      * @tc.expected: Check the CheckBoxGroup property value
1962      */
1963     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1964     ASSERT_NE(frameNode, nullptr);
1965     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
1966     ASSERT_NE(checkBoxPaintProperty, nullptr);
1967     auto json = JsonUtil::Create(true);
1968     checkBoxPaintProperty->ToJsonValue(json, filter);
1969     EXPECT_EQ(json->GetString("checkboxShape"), "1");
1970     AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
1971 }
1972 
1973 /**
1974  * @tc.name: CheckBoxGroupPatternTest030
1975  * @tc.desc: Test OnAfterModifyDone.
1976  * @tc.type: FUNC
1977  */
1978 HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupPatternTest030, TestSize.Level1)
1979 {
1980     /**
1981      * @tc.steps: step1. Init CheckBoxGroup node
1982      */
1983     int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
1984     AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_TWELVE));
1985     CheckBoxModelNG checkboxModelNG;
1986     checkboxModelNG.Create(NAME, GROUP_NAME, TAG);
1987     checkboxModelNG.SetCheckboxStyle(CheckBoxStyle::CIRCULAR_STYLE);
1988     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1989     EXPECT_NE(frameNode, nullptr);
1990     CheckBoxGroupModelNG checkboxGroupModelNG;
1991     checkboxGroupModelNG.Create(GROUP_NAME);
1992     checkboxGroupModelNG.SetCheckboxGroupStyle(CheckBoxStyle::SQUARE_STYLE);
1993     auto groupFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1994     EXPECT_NE(groupFrameNode, nullptr);
1995     auto pattern = groupFrameNode->GetPattern<CheckBoxGroupPattern>();
1996     EXPECT_NE(pattern, nullptr);
1997 
1998     CheckBoxGroupModifier::Parameters parameters = CheckBoxGroupCreateDefModifierParam();
1999     auto checkBoxGroupModifier = AceType::MakeRefPtr<CheckBoxGroupModifier>(parameters);
2000     EXPECT_NE(checkBoxGroupModifier, nullptr);
2001     pattern->UpdateCheckBoxStyle();
2002     /**
2003      * @tc.steps: step2. Get paint property and get CheckBoxGroup and CheckBox property
2004      * @tc.expected: Check the CheckBoxGroup and CheckBox property value
2005      */
2006     auto groupPaintProperty = groupFrameNode->GetPaintProperty<CheckBoxGroupPaintProperty>();
2007     EXPECT_NE(groupPaintProperty, nullptr);
2008     EXPECT_EQ(groupPaintProperty->GetCheckBoxGroupSelectedStyleValue(), CheckBoxStyle::SQUARE_STYLE);
2009     auto checkBoxPaintProperty = frameNode->GetPaintProperty<CheckBoxPaintProperty>();
2010     EXPECT_NE(checkBoxPaintProperty, nullptr);
2011     EXPECT_EQ(checkBoxPaintProperty->GetCheckBoxSelectedStyleValue(), CheckBoxStyle::CIRCULAR_STYLE);
2012     AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
2013 }
2014 } // namespace OHOS::Ace::NG
2015