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 "gtest/gtest.h"
16 #define protected public
17 #define private public
18 #include "base/geometry/dimension.h"
19 #include "core/components/checkable/checkable_theme.h"
20 #include "core/components/toggle/toggle_theme.h"
21 #include "core/components_ng/base/view_stack_processor.h"
22 #include "core/components_ng/pattern/button/toggle_button_event_hub.h"
23 #include "core/components_ng/pattern/button/toggle_button_paint_property.h"
24 #include "core/components_ng/pattern/button/toggle_button_pattern.h"
25 #include "core/components_ng/pattern/checkbox/checkbox_event_hub.h"
26 #include "core/components_ng/pattern/checkbox/checkbox_paint_property.h"
27 #include "core/components_ng/pattern/checkbox/checkbox_pattern.h"
28 #include "core/components_ng/pattern/toggle/switch_event_hub.h"
29 #include "core/components_ng/pattern/toggle/switch_paint_method.h"
30 #include "core/components_ng/pattern/toggle/switch_paint_property.h"
31 #include "core/components_ng/pattern/toggle/switch_pattern.h"
32 #include "core/components_ng/pattern/toggle/toggle_model.h"
33 #include "core/components_ng/pattern/toggle/toggle_model_ng.h"
34 #include "core/components_ng/test/mock/rosen/mock_canvas.h"
35 #include "core/components_ng/test/mock/theme/mock_theme_manager.h"
36 #include "core/components_v2/inspector/inspector_constants.h"
37 #include "core/pipeline_ng/test/mock/mock_pipeline_base.h"
38
39 using namespace testing;
40 using namespace testing::ext;
41 namespace OHOS::Ace::NG {
42 namespace {
43 constexpr bool IS_ON = true;
44 constexpr bool SKIP_MEASURE = true;
45 constexpr bool NO_SKIP_MEASURE = false;
46 constexpr float CONTAINER_WIDTH = 200.0f;
47 constexpr float CONTAINER_HEIGHT = 100.0f;
48 constexpr Color SELECTED_COLOR = Color(0XFFFF0000);
49 constexpr Color SWITCH_POINT_COLOR = Color(0XFFFFFF00);
50 constexpr Color BACKGROUND_COLOR = Color(0XFFFF0000);
51 constexpr Dimension ZERO = 0.0_px;
52 constexpr Dimension TOGGLE_WIDTH = 60.0_px;
53 constexpr Dimension TOGGLE_HEIGH = 20.0_px;
54 constexpr float SWITCH_WIDTH = 100.0f;
55 constexpr float SWITCH_HEIGHT = 50.0f;
56 constexpr Dimension PADDING = Dimension(5.0);
57 const SizeF CONTAINER_SIZE(CONTAINER_WIDTH, CONTAINER_HEIGHT);
58 const Alignment ALIGNMENT = Alignment::BOTTOM_RIGHT;
59 const std::vector<NG::ToggleType> TOGGLE_TYPE = { ToggleType::CHECKBOX, ToggleType::BUTTON, ToggleType::SWITCH };
60 } // namespace
61
62 class ToggleTestNg : public testing::Test {
63 public:
64 static void SetUpTestCase();
65 static void TearDownTestCase();
66
67 protected:
68 static PaddingPropertyF CreatePadding(Dimension length);
69 };
70
SetUpTestCase()71 void ToggleTestNg::SetUpTestCase()
72 {
73 MockPipelineBase::SetUp();
74 }
75
TearDownTestCase()76 void ToggleTestNg::TearDownTestCase()
77 {
78 MockPipelineBase::TearDown();
79 }
80
CreatePadding(Dimension length)81 PaddingPropertyF ToggleTestNg::CreatePadding(Dimension length)
82 {
83 PaddingPropertyF padding;
84 padding.left = length.ConvertToPx();
85 padding.right = length.ConvertToPx();
86 padding.top = length.ConvertToPx();
87 padding.bottom = length.ConvertToPx();
88 return padding;
89 }
90
91 /**
92 * @tc.name: TogglePatternTest001
93 * @tc.desc: test the process of toggle created with checkbox.
94 * @tc.type: FUNC
95 */
96 HWTEST_F(ToggleTestNg, TogglePatternTest001, TestSize.Level1)
97 {
98 /**
99 * @tc.steps: step1. create toggle and get frameNode.
100 */
101 ToggleModelNG toggleModelNG;
102 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
103 toggleModelNG.SetSelectedColor(SELECTED_COLOR);
104 auto checkBoxFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
105 EXPECT_NE(checkBoxFrameNode, nullptr);
106 EXPECT_EQ(checkBoxFrameNode->GetTag(), V2::CHECKBOX_ETS_TAG);
107
108 /**
109 * @tc.steps: step2.get checkBox property and check whether the property value is correct.
110 */
111 auto pattern = AceType::DynamicCast<CheckBoxPattern>(checkBoxFrameNode->GetPattern());
112 EXPECT_NE(pattern, nullptr);
113 auto paintProperty = pattern->GetPaintProperty<CheckBoxPaintProperty>();
114 EXPECT_NE(paintProperty, nullptr);
115 EXPECT_EQ(paintProperty->GetCheckBoxSelect(), IS_ON);
116 EXPECT_EQ(paintProperty->GetCheckBoxSelectedColor(), SELECTED_COLOR);
117 ViewStackProcessor::GetInstance()->ClearStack();
118
119 // update different toggle type
120 for (size_t i = 0; i < TOGGLE_TYPE.size(); ++i) {
121 ToggleModelNG toggleModelNG;
122 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
123
124 auto isOn = i % 2 == 0 ? true : false;
125 toggleModelNG.Create(TOGGLE_TYPE[i], isOn);
126 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
127 EXPECT_NE(frameNode, nullptr);
128
129 auto pattern = frameNode->GetPattern();
130 EXPECT_NE(pattern, nullptr);
131 if (AceType::InstanceOf<CheckBoxPattern>(pattern)) {
132 auto paintProperty = pattern->GetPaintProperty<CheckBoxPaintProperty>();
133 EXPECT_NE(paintProperty, nullptr);
134 EXPECT_EQ(paintProperty->GetCheckBoxSelect(), isOn);
135 }
136 if (AceType::InstanceOf<SwitchPattern>(pattern)) {
137 auto paintProperty = pattern->GetPaintProperty<SwitchPaintProperty>();
138 EXPECT_NE(paintProperty, nullptr);
139 EXPECT_EQ(paintProperty->GetIsOn(), isOn);
140 }
141 if (AceType::InstanceOf<ToggleButtonPattern>(pattern)) {
142 auto paintProperty = pattern->GetPaintProperty<ToggleButtonPaintProperty>();
143 EXPECT_NE(paintProperty, nullptr);
144 EXPECT_EQ(paintProperty->GetIsOn(), isOn);
145 }
146 ViewStackProcessor::GetInstance()->ClearStack();
147 }
148 }
149
150 /**
151 * @tc.name: TogglePatternTest002
152 * @tc.desc: test the process of toggle created with button.
153 * @tc.type: FUNC
154 */
155 HWTEST_F(ToggleTestNg, TogglePatternTest002, TestSize.Level1)
156 {
157 /**
158 * @tc.steps: step1. create toggle and get frameNode.
159 */
160 ToggleModelNG toggleModelNG;
161 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
162 toggleModelNG.SetSelectedColor(SELECTED_COLOR);
163 auto buttonFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
164 EXPECT_NE(buttonFrameNode, nullptr);
165 EXPECT_EQ(buttonFrameNode->GetTag(), V2::TOGGLE_ETS_TAG);
166
167 /**
168 * @tc.steps: step2.get button property and check whether the property value is correct.
169 */
170 auto paintProperty = buttonFrameNode->GetPaintProperty<ToggleButtonPaintProperty>();
171 EXPECT_NE(paintProperty, nullptr);
172 EXPECT_EQ(paintProperty->GetIsOn(), IS_ON);
173 EXPECT_EQ(paintProperty->GetSelectedColor(), SELECTED_COLOR);
174 }
175
176 /**
177 * @tc.name: TogglePatternTest003
178 * @tc.desc: test the process of toggle created with switch.
179 * @tc.type: FUNC
180 */
181 HWTEST_F(ToggleTestNg, TogglePatternTest003, TestSize.Level1)
182 {
183 /**
184 * @tc.steps: step1. create toggle and get frameNode.
185 */
186 ToggleModelNG toggleModelNG;
187 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
188 toggleModelNG.SetSelectedColor(SELECTED_COLOR);
189 toggleModelNG.SetSwitchPointColor(SWITCH_POINT_COLOR);
190 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
191 EXPECT_NE(switchFrameNode, nullptr);
192 EXPECT_EQ(switchFrameNode->GetTag(), V2::TOGGLE_ETS_TAG);
193 EXPECT_EQ(toggleModelNG.IsToggle(), false);
194
195 /**
196 * @tc.steps: step2.get switch property and check whether the property value is correct.
197 */
198 auto pattern = AceType::DynamicCast<SwitchPattern>(switchFrameNode->GetPattern());
199 EXPECT_NE(pattern, nullptr);
200 auto paintProperty = pattern->GetPaintProperty<SwitchPaintProperty>();
201 EXPECT_NE(paintProperty, nullptr);
202 EXPECT_EQ(paintProperty->GetIsOn(), IS_ON);
203 EXPECT_EQ(paintProperty->GetSelectedColor(), SELECTED_COLOR);
204 EXPECT_EQ(paintProperty->GetSwitchPointColor(), SWITCH_POINT_COLOR);
205 }
206
207 /**
208 * @tc.name: TogglePatternTest004
209 * @tc.desc: test toggle created SetWidth SetHeight SetBackgroundColor.
210 * @tc.type: FUNC
211 */
212 HWTEST_F(ToggleTestNg, TogglePatternTest004, TestSize.Level1)
213 {
214 /**
215 * @tc.steps: step1. create toggle and get frameNode.
216 */
217 ToggleModelNG toggleModelNG;
218 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
219 toggleModelNG.SetSelectedColor(SELECTED_COLOR);
220 toggleModelNG.SetWidth(TOGGLE_WIDTH);
221 toggleModelNG.SetHeight(TOGGLE_HEIGH);
222 toggleModelNG.SetBackgroundColor(BACKGROUND_COLOR);
223 auto padding = CreatePadding(ZERO);
224 NG::PaddingProperty newPadding(
225 { NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp) });
226 toggleModelNG.SetPadding(padding, newPadding);
227 auto buttonFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
228 EXPECT_NE(buttonFrameNode, nullptr);
229 EXPECT_EQ(buttonFrameNode->GetTag(), V2::TOGGLE_ETS_TAG);
230
231 /**
232 * @tc.steps: step2.get button property and check whether the property value is correct.
233 */
234 auto paintProperty = buttonFrameNode->GetPaintProperty<ToggleButtonPaintProperty>();
235 EXPECT_NE(paintProperty, nullptr);
236 EXPECT_EQ(paintProperty->GetIsOn(), IS_ON);
237 EXPECT_EQ(paintProperty->GetSelectedColor(), SELECTED_COLOR);
238 EXPECT_EQ(paintProperty->GetBackgroundColor(), BACKGROUND_COLOR);
239 }
240
241 /**
242 * @tc.name: TogglePatternTest005
243 * @tc.desc: Test event function of toggle with checkbox.
244 * @tc.type: FUNC
245 */
246 HWTEST_F(ToggleTestNg, TogglePatternTest005, TestSize.Level1)
247 {
248 /**
249 * @tc.steps: step1. create toggle and get frameNode.
250 */
251 ToggleModelNG toggleModelNG;
252 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
253 toggleModelNG.SetSelectedColor(SELECTED_COLOR);
254
255 /**
256 * @tc.steps: step2. set toggle event.
257 * @tc.expected: step2. function is called.
258 */
259 bool stateChange = true;
__anon0ff9a3400202(bool flag) 260 auto onChange = [&stateChange](bool flag) { stateChange = flag; };
261 toggleModelNG.OnChange(onChange);
262
263 /**
264 * @tc.steps: step3. call the event entry function.
265 * @tc.expected: step3. check whether the value is correct.
266 */
267 auto checkBoxFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
268 EXPECT_NE(checkBoxFrameNode, nullptr);
269 EXPECT_EQ(checkBoxFrameNode->GetTag(), V2::CHECKBOX_ETS_TAG);
270 auto eventHub = checkBoxFrameNode->GetEventHub<CheckBoxEventHub>();
271 EXPECT_FALSE(eventHub == nullptr);
272 eventHub->UpdateChangeEvent(false);
273 EXPECT_EQ(stateChange, false);
274
275 eventHub->UpdateChangeEvent(true);
276 EXPECT_EQ(stateChange, true);
277 }
278
279 /**
280 * @tc.name: TogglePatternTest006
281 * @tc.desc: Test event function of toggle with button.
282 * @tc.type: FUNC
283 */
284 HWTEST_F(ToggleTestNg, TogglePatternTest006, TestSize.Level1)
285 {
286 /**
287 * @tc.steps: step1. create toggle and get frameNode.
288 */
289 ToggleModelNG toggleModelNG;
290 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
291 toggleModelNG.SetSelectedColor(SELECTED_COLOR);
292
293 /**
294 * @tc.steps: step2. set toggle event.
295 * @tc.expected: step2. function is called.
296 */
297 bool stateChange = true;
__anon0ff9a3400302(bool flag) 298 auto onChange = [&stateChange](bool flag) { stateChange = flag; };
299 toggleModelNG.OnChange(onChange);
300
301 /**
302 * @tc.steps: step3. call the event entry function.
303 * @tc.expected: step3. check whether the value is correct.
304 */
305 auto buttonFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
306 EXPECT_NE(buttonFrameNode, nullptr);
307 EXPECT_EQ(buttonFrameNode->GetTag(), V2::TOGGLE_ETS_TAG);
308 auto eventHub = buttonFrameNode->GetEventHub<ToggleButtonEventHub>();
309 EXPECT_FALSE(eventHub == nullptr);
310 eventHub->UpdateChangeEvent(false);
311 EXPECT_EQ(stateChange, false);
312
313 eventHub->UpdateChangeEvent(true);
314 EXPECT_EQ(stateChange, true);
315 }
316
317 /**
318 * @tc.name: TogglePatternTest007
319 * @tc.desc: Test event function of toggle with switch.
320 * @tc.type: FUNC
321 */
322 HWTEST_F(ToggleTestNg, TogglePatternTest007, TestSize.Level1)
323 {
324 /**
325 * @tc.steps: step1. create toggle and get frameNode.
326 */
327 ToggleModelNG toggleModelNG;
328 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
329 toggleModelNG.SetSelectedColor(SELECTED_COLOR);
330 toggleModelNG.SetSwitchPointColor(SWITCH_POINT_COLOR);
331
332 /**
333 * @tc.steps: step2. set toggle event.
334 * @tc.expected: step2. function is called.
335 */
336 bool stateChange = true;
__anon0ff9a3400402(bool flag) 337 auto onChange = [&stateChange](bool flag) { stateChange = flag; };
338 toggleModelNG.OnChange(onChange);
339
340 /**
341 * @tc.steps: step3. call the event entry function.
342 * @tc.expected: step3. check whether the value is correct.
343 */
344 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
345 EXPECT_NE(switchFrameNode, nullptr);
346 EXPECT_EQ(switchFrameNode->GetTag(), V2::TOGGLE_ETS_TAG);
347 auto eventHub = switchFrameNode->GetEventHub<SwitchEventHub>();
348 EXPECT_NE(eventHub, nullptr);
349 eventHub->UpdateChangeEvent(true);
350 EXPECT_EQ(stateChange, true);
351 }
352
353 /**
354 * @tc.name: TogglePatternTest008
355 * @tc.desc: Test toggle OnModifyDone.
356 * @tc.type: FUNC
357 */
358 HWTEST_F(ToggleTestNg, TogglePatternTest008, TestSize.Level1)
359 {
360 /**
361 * @tc.steps: step1. create switch and get frameNode.
362 */
363 ToggleModelNG toggleModelNG;
364 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
365 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
366 EXPECT_NE(switchFrameNode, nullptr);
367
368 /**
369 * @tc.steps: step2. create switch frameNode, get switchPattern.
370 * @tc.expected: step2. get switchPattern success.
371 */
372 auto switchPattern = switchFrameNode->GetPattern<SwitchPattern>();
373 EXPECT_NE(switchPattern, nullptr);
374 auto layoutProperty = switchFrameNode->GetLayoutProperty();
375
376 // set switchTheme to themeManager before using themeManager to get switchTheme
377 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
378 MockPipelineBase::GetCurrent()->SetThemeManager(themeManager);
379 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SwitchTheme>()));
380 switchPattern->OnModifyDone();
381
382 // update layoutProperty and execute OnModifyDone again
383 layoutProperty->UpdateAlignment(ALIGNMENT);
384 MarginProperty margin;
385 margin.left = CalcLength(PADDING.ConvertToPx());
386 margin.right = CalcLength(PADDING.ConvertToPx());
387 margin.top = CalcLength(PADDING.ConvertToPx());
388 margin.bottom = CalcLength(PADDING.ConvertToPx());
389 layoutProperty->UpdateMargin(margin); // GetMarginProperty
390 switchPattern->isOn_ = false;
391 switchPattern->OnModifyDone();
392 EXPECT_EQ(ALIGNMENT, layoutProperty->GetPositionProperty()->GetAlignmentValue());
393 EXPECT_EQ(layoutProperty->GetMarginProperty()->left.value(), CalcLength(PADDING.ConvertToPx()));
394 EXPECT_EQ(layoutProperty->GetMarginProperty()->right.value(), CalcLength(PADDING.ConvertToPx()));
395 EXPECT_EQ(layoutProperty->GetMarginProperty()->top.value(), CalcLength(PADDING.ConvertToPx()));
396 EXPECT_EQ(layoutProperty->GetMarginProperty()->bottom.value(), CalcLength(PADDING.ConvertToPx()));
397
398 auto geometryNode = switchFrameNode->GetGeometryNode();
399 geometryNode->SetContentSize(SizeF(SWITCH_WIDTH, SWITCH_HEIGHT));
400 auto paintProperty = switchFrameNode->GetPaintProperty<SwitchPaintProperty>();
401 switchPattern->isOn_ = false;
402 paintProperty->UpdateIsOn(true);
403 switchPattern->OnModifyDone();
404 EXPECT_EQ(switchPattern->isOn_, true);
405 EXPECT_EQ(paintProperty->GetIsOnValue(), true);
406 }
407
408 /**
409 * @tc.name: TogglePatternTest009
410 * @tc.desc: Test toggle OnDirtyLayoutWrapperSwap.
411 * @tc.type: FUNC
412 */
413 HWTEST_F(ToggleTestNg, TogglePatternTest009, TestSize.Level1)
414 {
415 /**
416 * @tc.steps: step1. create switch and get frameNode.
417 */
418 ToggleModelNG toggleModelNG;
419 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
420 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
421 EXPECT_NE(switchFrameNode, nullptr);
422 /**
423 * @tc.steps: step2. get switchPattern and switchWrapper.
424 * @tc.expected: step2. get switchPattern success.
425 */
426 auto switchPattern = AceType::DynamicCast<SwitchPattern>(switchFrameNode->GetPattern());
427 EXPECT_NE(switchPattern, nullptr);
428 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
429 EXPECT_NE(geometryNode, nullptr);
430 RefPtr<LayoutProperty> layoutProperty = switchFrameNode->GetLayoutProperty();
431 EXPECT_NE(layoutProperty, nullptr);
432 RefPtr<LayoutWrapperNode> layoutWrapper =
433 AceType::MakeRefPtr<LayoutWrapperNode>(switchFrameNode, geometryNode, layoutProperty);
434 EXPECT_NE(layoutWrapper, nullptr);
435
436 /**
437 * @tc.steps: step3. call switchPattern OnDirtyLayoutWrapperSwap function, compare result.
438 * @tc.expected: step3. OnDirtyLayoutWrapperSwap success and result correct.
439 */
440 auto switchLayoutAlgorithm = AceType::MakeRefPtr<SwitchLayoutAlgorithm>();
441 RefPtr<LayoutAlgorithmWrapper> layoutAlgorithmWrapper =
442 AceType::MakeRefPtr<LayoutAlgorithmWrapper>(switchLayoutAlgorithm, SKIP_MEASURE);
443 layoutWrapper->SetLayoutAlgorithm(layoutAlgorithmWrapper);
444
445 /**
446 * @tc.steps: step4. call switchPattern OnDirtyLayoutWrapperSwap function, compare result.
447 * @tc.expected: step4. OnDirtyLayoutWrapperSwap success and result correct.
448 */
449 bool first_case = switchPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, true, true);
450 EXPECT_FALSE(first_case);
451 bool second_case = switchPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, false, false);
452 EXPECT_FALSE(second_case);
453 layoutAlgorithmWrapper = AceType::MakeRefPtr<LayoutAlgorithmWrapper>(switchLayoutAlgorithm, NO_SKIP_MEASURE);
454 layoutWrapper->SetLayoutAlgorithm(layoutAlgorithmWrapper);
455 switchPattern->isOn_ = true;
456 bool third_case = switchPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, true, false);
457 EXPECT_FALSE(third_case);
458 bool forth_case = switchPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, false, true);
459 EXPECT_TRUE(forth_case);
460 switchPattern->isOn_ = false;
461 bool fifth_case = switchPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, false, true);
462 EXPECT_TRUE(fifth_case);
463 }
464
465 /**
466 * @tc.name: TogglePatternTest0010
467 * @tc.desc: Test toggle OnDirtyLayoutWrapperSwap.
468 * @tc.type: FUNC
469 */
470 HWTEST_F(ToggleTestNg, TogglePatternTest0010, TestSize.Level1)
471 {
472 /**
473 * @tc.steps: step1. create switch and get frameNode.
474 */
475 ToggleModelNG toggleModelNG;
476 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
477 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
478 EXPECT_NE(switchFrameNode, nullptr);
479 /**
480 * @tc.steps: step2. get switchPattern and switchWrapper.
481 * @tc.expected: step2. get switchPattern success.
482 */
483 auto switchPattern = AceType::DynamicCast<SwitchPattern>(switchFrameNode->GetPattern());
484 EXPECT_NE(switchPattern, nullptr);
485
486 /**
487 * @tc.steps: step3 execute event function.
488 * @tc.expected: step2. check whether event function is executed successfully.
489 */
490 auto hub = switchPattern->GetEventHub<EventHub>();
491 EXPECT_NE(hub, nullptr);
492 auto gestureHub = hub->GetOrCreateGestureEventHub();
493 EXPECT_NE(gestureHub, nullptr);
494 // InitPanEvent()
495 switchPattern->InitPanEvent(gestureHub);
496 GestureEvent info;
497 info.SetInputEventType(InputEventType::AXIS);
498 switchPattern->panEvent_->actionStart_(info);
499 switchPattern->panEvent_->actionUpdate_(info);
500 switchPattern->panEvent_->actionEnd_(info);
501 switchPattern->panEvent_->actionCancel_();
502 info.SetInputEventType(InputEventType::TOUCH_SCREEN);
503 switchPattern->panEvent_->actionStart_(info);
504 switchPattern->panEvent_->actionUpdate_(info);
505 switchPattern->panEvent_->actionEnd_(info);
506 switchPattern->InitPanEvent(gestureHub);
507 // InitClickEvent()
508 switchPattern->InitClickEvent();
509 switchPattern->InitClickEvent();
510 // InitTouchEvent()
511 switchPattern->InitTouchEvent();
512 switchPattern->InitTouchEvent();
513 TouchEventInfo touchInfo("onTouch");
514 TouchLocationInfo touchInfo1(1);
515 touchInfo1.SetTouchType(TouchType::DOWN);
516 touchInfo.AddTouchLocationInfo(std::move(touchInfo1));
517 switchPattern->touchListener_->GetTouchEventCallback()(touchInfo);
518 TouchLocationInfo touchInfo2(2);
519 touchInfo2.SetTouchType(TouchType::UP);
520 touchInfo.AddTouchLocationInfo(std::move(touchInfo2));
521 switchPattern->touchListener_->GetTouchEventCallback()(touchInfo);
522 TouchLocationInfo touchInfo3(3);
523 touchInfo2.SetTouchType(TouchType::CANCEL);
524 touchInfo.AddTouchLocationInfo(std::move(touchInfo3));
525 switchPattern->touchListener_->GetTouchEventCallback()(touchInfo);
526
527 // InitMouseEvent()
528 switchPattern->InitMouseEvent();
529 EXPECT_NE(switchPattern->mouseEvent_, nullptr);
530 switchPattern->InitMouseEvent();
531
532 switchPattern->isOn_ = true;
533 switchPattern->OnClick();
534 switchPattern->OnTouchDown();
535 switchPattern->OnTouchUp();
536 switchPattern->UpdateChangeEvent();
537
538 // execute Handle function
539 switchPattern->HandleMouseEvent(true);
540 info.SetMainDelta(10.0f);
541 switchPattern->HandleDragUpdate(info);
542 info.SetMainDelta(0.0f);
543 switchPattern->HandleDragUpdate(info);
544
545 switchPattern->HandleDragEnd();
546 switchPattern->isOn_ = false;
547 switchPattern->HandleDragEnd();
548 // other branch
549 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
550 geometryNode->SetContentSize(SizeF(20, 10));
551 EXPECT_NE(geometryNode, nullptr);
552 RefPtr<LayoutProperty> layoutProperty = switchFrameNode->GetLayoutProperty();
553 EXPECT_NE(layoutProperty, nullptr);
554 RefPtr<LayoutWrapperNode> layoutWrapper =
555 AceType::MakeRefPtr<LayoutWrapperNode>(switchFrameNode, geometryNode, layoutProperty);
556 EXPECT_NE(layoutWrapper, nullptr);
557 auto switchLayoutAlgorithm = AceType::MakeRefPtr<SwitchLayoutAlgorithm>();
558 RefPtr<LayoutAlgorithmWrapper> layoutAlgorithmWrapper =
559 AceType::MakeRefPtr<LayoutAlgorithmWrapper>(switchLayoutAlgorithm, SKIP_MEASURE);
560 layoutWrapper->SetLayoutAlgorithm(layoutAlgorithmWrapper);
561 EXPECT_EQ(geometryNode->GetContentSize().Width(), 20);
562 switchPattern->HandleDragEnd();
563 switchPattern->isOn_ = true;
564 switchPattern->HandleDragEnd();
565 switchPattern->OnClick();
566 }
567
568 /**
569 * @tc.name: TogglePaintTest0011
570 * @tc.desc: Test toggle SetSelectedColor(undefined).
571 * @tc.type: FUNC
572 */
573 HWTEST_F(ToggleTestNg, TogglePatternTest0011, TestSize.Level1)
574 {
575 /**
576 * @tc.steps: step1. create switch and get frameNode.
577 */
578 ToggleModelNG toggleModelNG;
579 std::optional<Color> selectedColor = std::optional<Color>();
580
581 /**
582 * @tc.steps: step1. test checkbox
583 */
584 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
585 MockPipelineBase::GetCurrent()->SetThemeManager(themeManager);
586 auto checkboxTheme = AceType::MakeRefPtr<CheckboxTheme>();
587 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme));
588
589 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
590 toggleModelNG.SetSelectedColor(selectedColor);
591
592 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
593 EXPECT_NE(frameNode, nullptr);
594
595 auto checkboxPattern = AceType::DynamicCast<CheckBoxPattern>(frameNode->GetPattern());
596 EXPECT_NE(checkboxPattern, nullptr);
597 auto checkboxPaintProperty = checkboxPattern->GetPaintProperty<CheckBoxPaintProperty>();
598 EXPECT_NE(checkboxPaintProperty, nullptr);
599 EXPECT_EQ(checkboxPaintProperty->GetCheckBoxSelectedColor(), checkboxTheme->GetActiveColor());
600
601 /**
602 * @tc.steps: step2. test button
603 */
604 themeManager = AceType::MakeRefPtr<MockThemeManager>();
605 MockPipelineBase::GetCurrent()->SetThemeManager(themeManager);
606 auto toggleButtonTheme = AceType::MakeRefPtr<ToggleTheme>();
607 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(toggleButtonTheme));
608
609 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
610 toggleModelNG.SetSelectedColor(selectedColor);
611
612 frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
613 EXPECT_NE(frameNode, nullptr);
614 auto buttonPaintProperty = frameNode->GetPaintProperty<ToggleButtonPaintProperty>();
615 EXPECT_NE(buttonPaintProperty, nullptr);
616 EXPECT_EQ(buttonPaintProperty->GetSelectedColor(), toggleButtonTheme->GetCheckedColor());
617
618 /**
619 * @tc.steps: step3. test switch
620 */
621 themeManager = AceType::MakeRefPtr<MockThemeManager>();
622 MockPipelineBase::GetCurrent()->SetThemeManager(themeManager);
623 auto switchTheme = AceType::MakeRefPtr<SwitchTheme>();
624 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(switchTheme));
625
626 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
627 toggleModelNG.SetSelectedColor(selectedColor);
628
629 frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
630 EXPECT_NE(frameNode, nullptr);
631 auto switchPattern = AceType::DynamicCast<SwitchPattern>(frameNode->GetPattern());
632 EXPECT_NE(switchPattern, nullptr);
633 auto switchPaintProperty = switchPattern->GetPaintProperty<SwitchPaintProperty>();
634 EXPECT_NE(switchPaintProperty, nullptr);
635 EXPECT_EQ(switchPaintProperty->GetSelectedColor(), switchTheme->GetActiveColor());
636 }
637
638 /**
639 * @tc.name: TogglePatternTest0012
640 * @tc.desc: Test toggle OnModifyDone default margin.
641 * @tc.type: FUNC
642 */
643 HWTEST_F(ToggleTestNg, TogglePatternTest0012, TestSize.Level1)
644 {
645 /**
646 * @tc.steps: step1. create switch and get frameNode.
647 */
648 ToggleModelNG toggleModelNG;
649 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
650 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
651 EXPECT_NE(switchFrameNode, nullptr);
652
653 /**
654 * @tc.steps: step2. create switch frameNode, get switchPattern.
655 * @tc.expected: step2. get switchPattern success.
656 */
657 auto switchPattern = switchFrameNode->GetPattern<SwitchPattern>();
658 EXPECT_NE(switchPattern, nullptr);
659 auto layoutProperty = switchFrameNode->GetLayoutProperty();
660
661 // set switchTheme to themeManager before using themeManager to get switchTheme
662 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
663 MockPipelineBase::GetCurrent()->SetThemeManager(themeManager);
664 auto switchTheme = AceType::MakeRefPtr<SwitchTheme>();
665 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(switchTheme));
666
667 MarginProperty margin;
668 margin.left = CalcLength(PADDING.ConvertToPx());
669 layoutProperty->UpdateMargin(margin); // GetMarginProperty
670
671 switchPattern->OnModifyDone();
672 EXPECT_EQ(layoutProperty->GetMarginProperty()->left.value(), CalcLength(PADDING.ConvertToPx()));
673 EXPECT_EQ(layoutProperty->GetMarginProperty()->right.value(),
674 CalcLength(switchTheme->GetHotZoneHorizontalPadding().Value()));
675 EXPECT_EQ(
676 layoutProperty->GetMarginProperty()->top.value(), CalcLength(switchTheme->GetHotZoneVerticalPadding().Value()));
677 EXPECT_EQ(layoutProperty->GetMarginProperty()->bottom.value(),
678 CalcLength(switchTheme->GetHotZoneVerticalPadding().Value()));
679
680 MarginProperty margin1;
681 margin1.right = CalcLength(PADDING.ConvertToPx());
682 layoutProperty->UpdateMargin(margin1); // GetMarginProperty
683
684 switchPattern->OnModifyDone();
685 EXPECT_EQ(layoutProperty->GetMarginProperty()->right.value(), CalcLength(PADDING.ConvertToPx()));
686 EXPECT_EQ(layoutProperty->GetMarginProperty()->left.value(),
687 CalcLength(switchTheme->GetHotZoneHorizontalPadding().Value()));
688 EXPECT_EQ(
689 layoutProperty->GetMarginProperty()->top.value(), CalcLength(switchTheme->GetHotZoneVerticalPadding().Value()));
690 EXPECT_EQ(layoutProperty->GetMarginProperty()->bottom.value(),
691 CalcLength(switchTheme->GetHotZoneVerticalPadding().Value()));
692 }
693
694 /**
695 * @tc.name: TogglePatternTest0013
696 * @tc.desc: Test Toggle pattern method HandleMouseEvent, OnTouchUp and OnTouchDown.
697 * @tc.type: FUNC
698 */
699 HWTEST_F(ToggleTestNg, TogglePatternTest0013, TestSize.Level1)
700 {
701 /**
702 * @tc.steps: step1. Init Toggle node
703 */
704 ToggleModelNG toggleModelNG;
705 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
706
707 /**
708 * @tc.steps: step2. Get Toggle pattern object
709 */
710 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
711 ASSERT_NE(frameNode, nullptr);
712 auto pattern = frameNode->GetPattern<SwitchPattern>();
713 ASSERT_NE(pattern, nullptr);
714
715 /**
716 * @tc.steps: step3. Set Toggle pattern variable and call HandleMouseEvent, OnTouchUp and OnTouchDown
717 * @tc.expected: step3. Check the Toggle pattern value
718 */
719 pattern->isTouch_ = true;
720 pattern->isHover_ = false;
721 pattern->HandleMouseEvent(true);
722 EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::HOVER);
723 EXPECT_EQ(pattern->isTouch_, true);
724 pattern->HandleMouseEvent(false);
725 EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::NONE);
726
727 pattern->isTouch_ = true;
728 pattern->isHover_ = false;
729 pattern->OnTouchUp();
730 EXPECT_EQ(pattern->isTouch_, false);
731 EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::NONE);
732 pattern->isHover_ = true;
733 pattern->OnTouchUp();
734 EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::PRESS_TO_HOVER);
735
736 pattern->isTouch_ = false;
737 pattern->isHover_ = false;
738 pattern->OnTouchDown();
739 EXPECT_EQ(pattern->isTouch_, true);
740 EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::PRESS);
741 pattern->isHover_ = true;
742 pattern->OnTouchDown();
743 EXPECT_EQ(pattern->touchHoverType_, TouchHoverAnimationType::HOVER_TO_PRESS);
744 }
745
746 /**
747 * @tc.name: ToggleLayoutTest001
748 * @tc.desc: Test toggle layout.
749 * @tc.type: FUNC
750 */
751 HWTEST_F(ToggleTestNg, ToggleLayoutTest001, TestSize.Level1)
752 {
753 /**
754 * @tc.steps: step1. create switch and get frameNode.
755 */
756 ToggleModelNG toggleModelNG;
757 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
758 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
759 EXPECT_NE(switchFrameNode, nullptr);
760
761 /**
762 * @tc.steps: step2. get switchPattern and switchWrapper.
763 * @tc.expected: step2. get switchPattern success.
764 */
765 auto switchPattern = AceType::DynamicCast<SwitchPattern>(switchFrameNode->GetPattern());
766 EXPECT_NE(switchPattern, nullptr);
767 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
768 EXPECT_NE(switchFrameNode, nullptr);
769 LayoutWrapperNode layoutWrapper =
770 LayoutWrapperNode(switchFrameNode, geometryNode, switchFrameNode->GetLayoutProperty());
771 auto switchLayoutAlgorithm = AceType::DynamicCast<SwitchLayoutAlgorithm>(switchPattern->CreateLayoutAlgorithm());
772 EXPECT_NE(switchLayoutAlgorithm, nullptr);
773 layoutWrapper.SetLayoutAlgorithm(AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(switchLayoutAlgorithm));
774
775 /**
776 * @tc.steps: step3. update layoutWrapper.
777 */
778 // set switchTheme to themeManager before using themeManager to get switchTheme
779 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
780 MockPipelineBase::GetCurrent()->SetThemeManager(themeManager);
781
782 // update switchTheme values
783 auto switchTheme = AceType::MakeRefPtr<SwitchTheme>();
784 switchTheme->width_ = TOGGLE_WIDTH;
785 switchTheme->height_ = TOGGLE_HEIGH;
786 switchTheme->hotZoneHorizontalPadding_ = ZERO;
787 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(switchTheme));
788
789 LayoutConstraintF layoutConstraintSize;
790 layoutConstraintSize.maxSize = CONTAINER_SIZE;
791 auto switchSize = switchLayoutAlgorithm->MeasureContent(layoutConstraintSize, &layoutWrapper);
792 EXPECT_EQ(switchSize->Width(), 36);
793
794 LayoutConstraintF layoutConstraintSizeFirst;
795 layoutConstraintSizeFirst.maxSize = SizeF(30, 10);
796
797 // different branch: update frameWidth = frameHeight = 0
798 auto switchSizeOne = switchLayoutAlgorithm->MeasureContent(layoutConstraintSizeFirst, &layoutWrapper);
799 EXPECT_EQ(switchSizeOne->Width(), 18);
800
801 LayoutConstraintF layoutConstraintSizeSecond;
802 layoutConstraintSizeSecond.maxSize = CONTAINER_SIZE;
803 // different branch: update (frameWidth / frameHeight) > ratio = 1.8
804 layoutConstraintSizeSecond.selfIdealSize.SetSize(SizeF(SWITCH_WIDTH, SWITCH_HEIGHT));
805 auto switchSizeSecond = switchLayoutAlgorithm->MeasureContent(layoutConstraintSizeSecond, &layoutWrapper);
806 EXPECT_EQ(switchSizeSecond->Width(), 90);
807
808 LayoutConstraintF layoutConstraintSizeThird;
809 layoutConstraintSizeThird.maxSize = CONTAINER_SIZE;
810 // different branch: update (frameWidth / frameHeight) < ratio = 1.8
811 layoutConstraintSizeThird.selfIdealSize.SetSize(SizeF(60, 40));
812 auto switchSizeThird = switchLayoutAlgorithm->MeasureContent(layoutConstraintSizeThird, &layoutWrapper);
813 EXPECT_EQ(switchSizeThird->Width(), 60);
814
815 LayoutConstraintF layoutConstraintSizeForth;
816 layoutConstraintSizeForth.maxSize = CONTAINER_SIZE;
817 // different branch: update (frameWidth / frameHeight) = ratio = 1.8
818 layoutConstraintSizeForth.selfIdealSize.SetSize(SizeF(180, 100));
819 auto switchSizeForth = switchLayoutAlgorithm->MeasureContent(layoutConstraintSizeForth, &layoutWrapper);
820 EXPECT_EQ(switchSizeForth->Width(), 180);
821 }
822
823 /**
824 * @tc.name: TogglePaintTest001
825 * @tc.desc: Test toggle PaintContent.
826 * @tc.type: FUNC
827 */
828 HWTEST_F(ToggleTestNg, TogglePaintTest001, TestSize.Level1)
829 {
830 /**
831 * @tc.steps: step1. create switch and get frameNode.
832 */
833 ToggleModelNG toggleModelNG;
834 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
835 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
836 EXPECT_NE(switchFrameNode, nullptr);
837 auto switchModifier = AceType::MakeRefPtr<SwitchModifier>(false, SELECTED_COLOR, 0.0f);
838 SwitchPaintMethod switchPaintMethod = SwitchPaintMethod(switchModifier);
839
840 /**
841 * @tc.steps: step2. get paintWrapper
842 * @tc.expected: paintWrapper is not null
843 */
844 RefPtr<RenderContext> renderContext;
845 auto switchPaintProperty = switchFrameNode->GetPaintProperty<SwitchPaintProperty>();
846 EXPECT_NE(switchPaintProperty, nullptr);
847 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
848 auto* paintWrapper = new PaintWrapper(renderContext, geometryNode, switchPaintProperty);
849 EXPECT_NE(paintWrapper, nullptr);
850
851 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
852 MockPipelineBase::GetCurrent()->SetThemeManager(themeManager);
853 auto switchTheme = AceType::MakeRefPtr<SwitchTheme>();
854 switchTheme->width_ = TOGGLE_WIDTH;
855 switchTheme->height_ = TOGGLE_HEIGH;
856 switchTheme->hotZoneHorizontalPadding_ = ZERO;
857 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(switchTheme));
858
859 Testing::MockCanvas rsCanvas;
860 EXPECT_CALL(rsCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rsCanvas));
861 EXPECT_CALL(rsCanvas, DrawRoundRect(_)).Times(AtLeast(1));
862 EXPECT_CALL(rsCanvas, DrawCircle(_, _)).Times(AtLeast(1));
863
864 auto contentSize = SizeF(100, 50);
865 auto contentOffset = OffsetF(0, 0);
866 switchPaintMethod.switchModifier_->PaintSwitch(rsCanvas, contentOffset, contentSize);
867 }
868
869 /**
870 * @tc.name: TogglePaintTest002
871 * @tc.desc: Test Toggle UpdateAnimatableProperty and SetBoardColor.
872 * @tc.type: FUNC
873 */
874 HWTEST_F(ToggleTestNg, TogglePaintTest002, TestSize.Level1)
875 {
876 auto switchModifier = AceType::MakeRefPtr<SwitchModifier>(false, SELECTED_COLOR, 0.0f);
877 switchModifier->hoverColor_ = Color::RED;
878 switchModifier->clickEffectColor_ = Color::BLUE;
879 switchModifier->touchHoverType_ = TouchHoverAnimationType::HOVER;
880 switchModifier->UpdateAnimatableProperty();
881 switchModifier->animateTouchHoverColor_ =
882 AceType::MakeRefPtr<AnimatablePropertyColor>(LinearColor(Color::TRANSPARENT));
883 switchModifier->touchHoverType_ = TouchHoverAnimationType::PRESS_TO_HOVER;
884 switchModifier->UpdateAnimatableProperty();
885 EXPECT_EQ(switchModifier->animateTouchHoverColor_->Get(), LinearColor(Color::RED));
886 switchModifier->touchHoverType_ = TouchHoverAnimationType::NONE;
887 switchModifier->UpdateAnimatableProperty();
888 EXPECT_EQ(switchModifier->animateTouchHoverColor_->Get(), LinearColor(Color::RED.BlendOpacity(0)));
889 switchModifier->touchHoverType_ = TouchHoverAnimationType::HOVER_TO_PRESS;
890 switchModifier->UpdateAnimatableProperty();
891 EXPECT_EQ(switchModifier->animateTouchHoverColor_->Get(), LinearColor(Color::BLUE));
892 switchModifier->touchHoverType_ = TouchHoverAnimationType::PRESS;
893 switchModifier->UpdateAnimatableProperty();
894 EXPECT_EQ(switchModifier->animateTouchHoverColor_->Get(), LinearColor(Color::BLUE));
895 EXPECT_EQ(switchModifier->isFirstCreated_, false);
896 switchModifier->isDragEvent_ = true;
897 switchModifier->SetDragOffsetX(0.0f);
898 switchModifier->UpdateAnimatableProperty();
899 EXPECT_EQ(switchModifier->pointOffset_->Get(), 0.0f);
900 }
901
902 /**
903 * @tc.name: TogglePaintTest004
904 * @tc.desc: Test SwitchPaintMethod GetContentModifier UpdateContentModifier.
905 * @tc.type: FUNC
906 */
907 HWTEST_F(ToggleTestNg, TogglePaintTest004, TestSize.Level1)
908 {
909 /**
910 * @tc.steps: step1. create switch and get frameNode.
911 */
912 ToggleModelNG toggleModelNG;
913 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
914 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
915 ASSERT_NE(switchFrameNode, nullptr);
916 auto switchModifier = AceType::MakeRefPtr<SwitchModifier>(IS_ON, SELECTED_COLOR, 0.0f);
917 SwitchPaintMethod switchPaintMethod = SwitchPaintMethod(switchModifier);
918 /**
919 * @tc.steps: step2. get paintWrapper
920 * @tc.expected: paintWrapper is not null
921 */
922 auto renderContext = switchFrameNode->GetRenderContext();
923 ASSERT_NE(renderContext, nullptr);
924 auto geometryNode = switchFrameNode->GetGeometryNode();
925 ASSERT_NE(geometryNode, nullptr);
926 auto paintProperty = switchFrameNode->GetPaintProperty<SwitchPaintProperty>();
927 ASSERT_NE(paintProperty, nullptr);
928 auto* paintWrapper = new PaintWrapper(renderContext, geometryNode, paintProperty);
929 ASSERT_NE(paintWrapper, nullptr);
930
931 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
932 MockPipelineBase::GetCurrent()->SetThemeManager(themeManager);
933 auto switchTheme = AceType::MakeRefPtr<SwitchTheme>();
934 switchTheme->width_ = TOGGLE_WIDTH;
935 switchTheme->height_ = TOGGLE_HEIGH;
936 switchTheme->hotZoneHorizontalPadding_ = ZERO;
937 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(switchTheme));
938
939 EXPECT_EQ(switchModifier, switchPaintMethod.GetContentModifier(paintWrapper));
940 switchPaintMethod.UpdateContentModifier(paintWrapper);
941 EXPECT_EQ(switchModifier->activeColor_, switchTheme->GetActiveColor());
942 }
943
944 /**
945 * @tc.name: TogglePaintTest003
946 * @tc.desc: Test SwitchPaintMethod GetSwitchWidth.
947 * @tc.type: FUNC
948 */
949 HWTEST_F(ToggleTestNg, TogglePaintTest003, TestSize.Level1)
950 {
951 /**
952 * @tc.steps: step1. create switch and get frameNode.
953 */
954 ToggleModelNG toggleModelNG;
955 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
956 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
957 ASSERT_NE(switchFrameNode, nullptr);
958 auto switchModifier = AceType::MakeRefPtr<SwitchModifier>(IS_ON, SELECTED_COLOR, 0.0f);
959 SwitchPaintMethod switchPaintMethod = SwitchPaintMethod(switchModifier);
960
961 auto switchTheme = MockPipelineBase::GetCurrent()->GetTheme<SwitchTheme>();
962 ASSERT_NE(switchTheme, nullptr);
963 switchTheme->height_ = TOGGLE_HEIGH;
964 switchTheme->hotZoneVerticalPadding_ = ZERO;
965
966 SizeF size(80.0f, 20.0f);
967 auto switchWidth = switchModifier->GetSwitchWidth(size);
968 EXPECT_EQ(switchWidth, 62.0f);
969 }
970
971 /**
972 * @tc.name: TogglePatternTest0017
973 * @tc.desc: Test toggle AddHotZoneRect RemoveLastHotZoneRect.
974 * @tc.type: FUNC
975 */
976 HWTEST_F(ToggleTestNg, TogglePatternTest0017, TestSize.Level1)
977 {
978 /**
979 * @tc.steps: step1. create switch and get frameNode.
980 */
981 ToggleModelNG toggleModelNG;
982 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
983 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
984 ASSERT_NE(switchFrameNode, nullptr);
985 auto switchPattern = switchFrameNode->GetPattern<SwitchPattern>();
986 ASSERT_NE(switchPattern, nullptr);
987 auto geometryNode = switchFrameNode->GetGeometryNode();
988 ASSERT_NE(geometryNode, nullptr);
989 OffsetF offsetF(0.0f, 0.0f);
990 SizeF sizeF(80.0f, 20.0f);
991 geometryNode->SetContentOffset(offsetF);
992 geometryNode->SetContentSize(sizeF);
993 auto layoutProperty = switchFrameNode->GetLayoutProperty();
994 ASSERT_NE(layoutProperty, nullptr);
995
996 RefPtr<LayoutWrapperNode> layoutWrapper =
997 AceType::MakeRefPtr<LayoutWrapperNode>(switchFrameNode, geometryNode, layoutProperty);
998 ASSERT_NE(layoutWrapper, nullptr);
999 auto switchLayoutAlgorithm = AceType::MakeRefPtr<SwitchLayoutAlgorithm>();
1000 RefPtr<LayoutAlgorithmWrapper> layoutAlgorithmWrapper =
1001 AceType::MakeRefPtr<LayoutAlgorithmWrapper>(switchLayoutAlgorithm, false);
1002 layoutWrapper->SetLayoutAlgorithm(layoutAlgorithmWrapper);
1003 bool result = switchPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, false, false);
1004 EXPECT_TRUE(result);
1005 /**
1006 * cover method AddHotZoneRect
1007 */
1008 switchPattern->AddHotZoneRect();
1009 EXPECT_EQ(switchPattern->hotZoneOffset_.GetX(), 0.0f);
1010 EXPECT_EQ(switchPattern->hotZoneSize_.Width(), 80.0f);
1011 /**
1012 * cover method RemoveLastHotZoneRect
1013 */
1014 switchPattern->RemoveLastHotZoneRect();
1015 int count = switchFrameNode->GetOrCreateGestureEventHub()->responseRegion_.size();
1016 for (size_t i = 0; i < count; i++) {
1017 switchPattern->RemoveLastHotZoneRect();
1018 }
1019
1020 EXPECT_EQ(switchFrameNode->GetOrCreateGestureEventHub()->isResponseRegion_, false);
1021 }
1022
1023 /**
1024 * @tc.name: TogglePatternTest0014
1025 * @tc.desc: Test toggle clickCallback of InitClickEvent InitMouseEvent.
1026 * @tc.type: FUNC
1027 */
1028 HWTEST_F(ToggleTestNg, TogglePatternTest0014, TestSize.Level1)
1029 {
1030 /**
1031 * @tc.steps: step1. create switch and get frameNode.
1032 */
1033 ToggleModelNG toggleModelNG;
1034 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1035 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1036 ASSERT_NE(switchFrameNode, nullptr);
1037 switchFrameNode->MarkModifyDone();
1038
1039 auto gesture = switchFrameNode->GetOrCreateGestureEventHub();
1040 ASSERT_NE(gesture, nullptr);
1041 /**
1042 * fire click event
1043 */
1044 gesture->ActClick();
1045 /**
1046 * fire mouse event
1047 */
1048 auto eventHub = switchFrameNode->GetEventHub<SwitchEventHub>();
1049 auto inputHub = eventHub->GetOrCreateInputEventHub();
1050 ASSERT_NE(inputHub, nullptr);
1051 auto hoverEventActuator = inputHub->hoverEventActuator_;
1052 ASSERT_NE(hoverEventActuator, nullptr);
1053 auto mouseEvents = hoverEventActuator->inputEvents_;
1054 ASSERT_NE(mouseEvents.size(), 0);
1055 for (const auto& callback : mouseEvents) {
1056 (*callback)(false);
1057 }
1058 }
1059
1060 /**
1061 * @tc.name: TogglePatternTest0015
1062 * @tc.desc: Test toggle clickCallback of InitOnKeyEvent.
1063 * @tc.type: FUNC
1064 */
1065 HWTEST_F(ToggleTestNg, TogglePatternTest0015, TestSize.Level1)
1066 {
1067 /**
1068 * @tc.steps: step1. create switch and get frameNode.
1069 */
1070 ToggleModelNG toggleModelNG;
1071 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1072 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1073 ASSERT_NE(switchFrameNode, nullptr);
1074 switchFrameNode->MarkModifyDone();
1075
1076 auto eventHub = switchFrameNode->GetFocusHub();
1077 ASSERT_NE(eventHub, nullptr);
1078 /**
1079 * test event.action != KeyAction::DOWN
1080 */
1081 KeyEvent keyEventOne(KeyCode::KEY_A, KeyAction::UP);
1082 eventHub->ProcessOnKeyEventInternal(keyEventOne);
1083 /**
1084 * test event.action == KeyAction::DOWN and event.code == KeyCode::KEY_ENTER
1085 */
1086 KeyEvent keyEventTwo(KeyCode::KEY_A, KeyAction::DOWN);
1087 eventHub->ProcessOnKeyEventInternal(keyEventTwo);
1088 /**
1089 * test event.action == KeyAction::DOWN and event.code != KeyCode::KEY_ENTER
1090 */
1091 KeyEvent keyEventThr(KeyCode::KEY_ENTER, KeyAction::DOWN);
1092 eventHub->ProcessOnKeyEventInternal(keyEventThr);
1093 }
1094
1095 /**
1096 * @tc.name: TogglePatternTest0016
1097 * @tc.desc: Test toggle GetInnerFocusPaintRect.
1098 * @tc.type: FUNC
1099 */
1100 HWTEST_F(ToggleTestNg, TogglePatternTest0016, TestSize.Level1)
1101 {
1102 /**
1103 * @tc.steps: step1. create switch and get frameNode.
1104 */
1105 ToggleModelNG toggleModelNG;
1106 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1107 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1108 ASSERT_NE(switchFrameNode, nullptr);
1109 switchFrameNode->MarkModifyDone();
1110
1111 auto eventHub = switchFrameNode->GetFocusHub();
1112 ASSERT_NE(eventHub, nullptr);
1113 RoundRect paintRect;
1114 eventHub->getInnerFocusRectFunc_(paintRect);
1115 }
1116
1117 /**
1118 * @tc.name: ToggleModelTest001
1119 * @tc.desc: Test toggle create.
1120 * @tc.type: FUNC
1121 */
1122 HWTEST_F(ToggleTestNg, ToggleModelTest001, TestSize.Level1)
1123 {
1124 const RefPtr<FrameNode> frameParent = FrameNode::CreateFrameNode("parent", 0, AceType::MakeRefPtr<Pattern>(), true);
1125 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1126 /**
1127 * @tc.steps: step1. create switch and get frameNode.
1128 */
1129 ToggleModelNG toggleModelNG;
1130 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1131 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1132 ASSERT_NE(switchFrameNode, nullptr);
1133 EXPECT_EQ(switchFrameNode->GetId(), 100);
1134 switchFrameNode->SetParent(frameParent);
1135 /**
1136 * Create again,cover all branches in function Create for switch
1137 */
1138 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1139 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1140 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1141 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
1142 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1143 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1144 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1145 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
1146 }
1147
1148 /**
1149 * @tc.name: ToggleModelTest002
1150 * @tc.desc: Test toggle create.
1151 * @tc.type: FUNC
1152 */
1153 HWTEST_F(ToggleTestNg, ToggleModelTest002, TestSize.Level1)
1154 {
1155 const RefPtr<FrameNode> frameParent = FrameNode::CreateFrameNode("parent", 0, AceType::MakeRefPtr<Pattern>(), true);
1156 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1157 /**
1158 * @tc.steps: step1. create checkbox and get frameNode.
1159 */
1160 ToggleModelNG toggleModelNG;
1161 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
1162 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1163 ASSERT_NE(switchFrameNode, nullptr);
1164 EXPECT_EQ(switchFrameNode->GetId(), 100);
1165 switchFrameNode->SetParent(frameParent);
1166 /**
1167 * Create again,cover all branches in function Create for checkbox
1168 */
1169 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1170 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
1171 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1172 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
1173 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1174 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
1175 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1176 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1177 }
1178
1179 /**
1180 * @tc.name: ToggleModelTest003
1181 * @tc.desc: Test toggle create.
1182 * @tc.type: FUNC
1183 */
1184 HWTEST_F(ToggleTestNg, ToggleModelTest003, TestSize.Level1)
1185 {
1186 const RefPtr<FrameNode> frameParent = FrameNode::CreateFrameNode("parent", 0, AceType::MakeRefPtr<Pattern>(), true);
1187 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1188 /**
1189 * @tc.steps: step1. create ToggleButton and get frameNode.
1190 */
1191 ToggleModelNG toggleModelNG;
1192 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
1193 auto switchFrameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1194 ASSERT_NE(switchFrameNode, nullptr);
1195 EXPECT_EQ(switchFrameNode->GetId(), 100);
1196 switchFrameNode->SetParent(frameParent);
1197 /**
1198 * Create again,cover all branches in function Create for ToggleButton
1199 */
1200 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1201 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
1202 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1203 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
1204 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1205 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
1206 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1207 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1208 }
1209
1210 /**
1211 * @tc.name: TogglePatternTest0019
1212 * @tc.desc: Test toggle HandleDragEnd.
1213 * @tc.type: FUNC
1214 */
1215 HWTEST_F(ToggleTestNg, TogglePatternTest0019, TestSize.Level1)
1216 {
1217 /**
1218 * @tc.steps: step1. create switch and get frameNode.
1219 */
1220 ToggleModelNG toggleModelNG;
1221 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1222 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1223 ASSERT_NE(frameNode, nullptr);
1224 auto pattern = frameNode->GetPattern<SwitchPattern>();
1225 ASSERT_NE(pattern, nullptr);
1226 auto geometryNode = frameNode->GetGeometryNode();
1227 geometryNode->SetContentSize(SizeF(SWITCH_WIDTH, SWITCH_HEIGHT));
1228 /**
1229 * @tc.steps: step2. call function HandleDragEnd.
1230 */
1231 pattern->dragOffsetX_ = 0;
1232 pattern->HandleDragEnd();
1233 pattern->dragOffsetX_ = SWITCH_WIDTH;
1234 pattern->HandleDragEnd();
1235 EXPECT_FALSE(pattern->isDragEvent_);
1236 /**
1237 * cover isOn_ == false branch.
1238 */
1239 pattern->isOn_ = false;
1240 pattern->HandleDragEnd();
1241 pattern->dragOffsetX_ = 0;
1242 pattern->HandleDragEnd();
1243 EXPECT_FALSE(pattern->isDragEvent_);
1244 }
1245
1246 /**
1247 * @tc.name: ToggleModelTest004
1248 * @tc.desc: Test checkbox create twice.
1249 * @tc.type: FUNC
1250 */
1251 HWTEST_F(ToggleTestNg, ToggleModelTest004, TestSize.Level1)
1252 {
1253 /**
1254 * @tc.steps: step1. create the first checkbox.
1255 */
1256 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1257 ToggleModelNG toggleModelNG;
1258 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
1259 auto checkboxNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1260 ASSERT_NE(checkboxNode, nullptr);
1261 EXPECT_EQ(checkboxNode->GetId(), 100);
1262 /**
1263 * @tc.steps: step2. create the second checkbox.
1264 */
1265 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1266 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
1267 }
1268
1269 /**
1270 * @tc.name: ToggleModelTest005
1271 * @tc.desc: Test ToggleButton create twice.
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(ToggleTestNg, ToggleModelTest005, TestSize.Level1)
1275 {
1276 /**
1277 * @tc.steps: step1. create the first ToggleButton.
1278 */
1279 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1280 ToggleModelNG toggleModelNG;
1281 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
1282 auto buttonNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1283 ASSERT_NE(buttonNode, nullptr);
1284 EXPECT_EQ(buttonNode->GetId(), 100);
1285 /**
1286 * @tc.steps: step2. create the second ToggleButton.
1287 */
1288 ViewStackProcessor::GetInstance()->StartGetAccessRecordingFor(100);
1289 toggleModelNG.Create(TOGGLE_TYPE[1], IS_ON);
1290 }
1291
1292 /**
1293 * @tc.name: ToggleModelTest006
1294 * @tc.desc: Test OnChangeEvent.
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(ToggleTestNg, ToggleModelTest006, TestSize.Level1)
1298 {
1299 /**
1300 * @tc.steps: step1. generate ChangeEvent.
1301 */
1302 ChangeEvent changeEvent;
1303 /**
1304 * @tc.steps: step2. create checkbox toggle and trigger OnChangeEvent.
1305 */
1306 ToggleModelNG toggleModelNG;
1307 toggleModelNG.Create(TOGGLE_TYPE[0], IS_ON);
1308 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1309 ASSERT_NE(frameNode, nullptr);
1310 toggleModelNG.OnChangeEvent(std::move(changeEvent));
1311 /**
1312 * @tc.steps: step3. create ToggleButton and trigger OnChangeEvent.
1313 */
1314 ToggleModelNG toggleModelNG2;
1315 toggleModelNG2.Create(TOGGLE_TYPE[1], IS_ON);
1316 frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1317 ASSERT_NE(frameNode, nullptr);
1318 toggleModelNG2.OnChangeEvent(std::move(changeEvent));
1319 /**
1320 * @tc.steps: step4. create switch toggle and trigger OnChangeEvent.
1321 */
1322 ToggleModelNG toggleModelNG3;
1323 toggleModelNG3.Create(TOGGLE_TYPE[2], IS_ON);
1324 frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1325 ASSERT_NE(frameNode, nullptr);
1326 toggleModelNG3.OnChangeEvent(std::move(changeEvent));
1327 }
1328
1329 /**
1330 * @tc.name: ToggleModelDistributedTest001
1331 * @tc.desc: Test the distributed capability of Toggle
1332 * @tc.type: FUNC
1333 */
1334 HWTEST_F(ToggleTestNg, ToggleModelDistributedTest001, TestSize.Level1)
1335 {
1336 /**
1337 * @tc.steps: step1. create switch and get frameNode.
1338 */
1339 ToggleModelNG toggleModelNG;
1340 toggleModelNG.Create(TOGGLE_TYPE[2], IS_ON);
1341 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1342 ASSERT_NE(frameNode, nullptr);
1343 auto pattern = frameNode->GetPattern<SwitchPattern>();
1344 ASSERT_NE(pattern, nullptr);
1345 auto switchPaintProperty = pattern->GetPaintProperty<SwitchPaintProperty>();
1346 ASSERT_NE(switchPaintProperty, nullptr);
1347
1348 /**
1349 * @tc.expected: Function ProvideRestoreInfo is called.
1350 */
1351 pattern->isOn_ = false;
1352 std::string ret = pattern->ProvideRestoreInfo();
1353 EXPECT_TRUE(ret == R"({"IsOn":false})");
1354
1355 /**
1356 * @tc.steps: step3. Function OnRestoreInfo is called.
1357 * @tc.expected: Passing invalid & valid JSON format.
1358 */
1359 std::string restoreInfo_ = R"({"IsOn":true})";
1360 pattern->OnRestoreInfo(restoreInfo_);
1361 EXPECT_TRUE(switchPaintProperty->GetIsOnValue(false));
1362 restoreInfo_ = "invalid_json_string";
1363 pattern->OnRestoreInfo(restoreInfo_);
1364 ASSERT_NE(switchPaintProperty, nullptr);
1365 EXPECT_TRUE(switchPaintProperty->GetIsOnValue(false));
1366 }
1367
1368 /**
1369 * @tc.name: ToggleAccessibilityPropertyTestNg001
1370 * @tc.desc: Test the IsCheckable and IsChecked properties of ToggleButton.
1371 * @tc.type: FUNC
1372 */
1373 HWTEST_F(ToggleTestNg, ToggleAccessibilityPropertyTestNg001, TestSize.Level1)
1374 {
1375 ToggleModelNG toggleModelNG;
1376 toggleModelNG.Create(ToggleType::BUTTON, true);
1377 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1378 ASSERT_NE(frameNode, nullptr);
1379
1380 auto accessibility = frameNode->GetAccessibilityProperty<ToggleButtonAccessibilityProperty>();
1381 ASSERT_NE(accessibility, nullptr);
1382 EXPECT_TRUE(accessibility->IsCheckable());
1383 EXPECT_TRUE(accessibility->IsChecked());
1384
1385 auto paintProperty = frameNode->GetPaintProperty<ToggleButtonPaintProperty>();
1386 ASSERT_NE(paintProperty, nullptr);
1387 paintProperty->UpdateIsOn(false);
1388 EXPECT_FALSE(accessibility->IsChecked());
1389 }
1390
1391 /**
1392 * @tc.name: ToggleAccessibilityPropertyTestNg002
1393 * @tc.desc: Test the IsCheckable and IsChecked properties of Switch.
1394 * @tc.type: FUNC
1395 */
1396 HWTEST_F(ToggleTestNg, ToggleAccessibilityPropertyTestNg002, TestSize.Level1)
1397 {
1398 ToggleModelNG toggleModelNG;
1399 toggleModelNG.Create(ToggleType::SWITCH, true);
1400 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1401 ASSERT_NE(frameNode, nullptr);
1402
1403 auto accessibility = frameNode->GetAccessibilityProperty<SwitchAccessibilityProperty>();
1404 ASSERT_NE(accessibility, nullptr);
1405 EXPECT_TRUE(accessibility->IsCheckable());
1406
1407 auto pattern = AceType::DynamicCast<SwitchPattern>(frameNode->GetPattern());
1408 ASSERT_NE(pattern, nullptr);
1409 pattern->isOn_ = false;
1410 EXPECT_FALSE(accessibility->IsChecked());
1411
1412 pattern->isOn_ = true;
1413 EXPECT_TRUE(accessibility->IsChecked());
1414 }
1415 } // namespace OHOS::Ace::NG
1416