diff --git a/frameworks/core/components_ng/pattern/button/button_layout_algorithm.cpp b/frameworks/core/components_ng/pattern/button/button_layout_algorithm.cpp index 5228fbf600936ba553a3fe3fb0ac8bad0a4f5b9b..ef064c588bc10410c8ccb36c6e83a567227b08fc 100644 --- a/frameworks/core/components_ng/pattern/button/button_layout_algorithm.cpp +++ b/frameworks/core/components_ng/pattern/button/button_layout_algorithm.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -175,6 +175,7 @@ std::optional ButtonLayoutAlgorithm::HandleLabelCircleButtonConstraint(La void ButtonLayoutAlgorithm::HandleAdaptiveText(LayoutWrapper* layoutWrapper, LayoutConstraintF& layoutConstraint) { + CHECK_NULL_VOID(layoutWrapper); auto buttonLayoutProperty = DynamicCast(layoutWrapper->GetLayoutProperty()); CHECK_NULL_VOID(buttonLayoutProperty); auto host = layoutWrapper->GetHostNode(); @@ -185,6 +186,20 @@ void ButtonLayoutAlgorithm::HandleAdaptiveText(LayoutWrapper* layoutWrapper, Lay CHECK_NULL_VOID(buttonTheme); auto childWrapper = layoutWrapper->GetOrCreateChildByIndex(0); CHECK_NULL_VOID(childWrapper); + // label type Without the general ability to use components, pass FIX_AT_IDEAL_SIZE to the child directly. + auto layoutPolicy = buttonLayoutProperty->GetLayoutPolicyProperty(); + if (layoutPolicy && layoutPolicy->IsFix()) { + auto widthLayoutPolicy = layoutPolicy.value().widthLayoutPolicy_; + auto heightLayoutPolicy = layoutPolicy.value().heightLayoutPolicy_; + for (auto&& child : layoutWrapper->GetAllChildrenWithBuild()) { + auto childLayoutPolicy = child->GetLayoutProperty(); + CHECK_NULL_VOID(childLayoutPolicy); + childLayoutPolicy->UpdateLayoutPolicyProperty(widthLayoutPolicy.value_or(LayoutCalPolicy::NO_MATCH), true); + childLayoutPolicy->UpdateLayoutPolicyProperty(heightLayoutPolicy.value_or(LayoutCalPolicy::NO_MATCH), + false); + } + } + if (buttonLayoutProperty->HasFontSize() || buttonLayoutProperty->HasControlSize()) { auto childConstraint = layoutWrapper->GetLayoutProperty()->GetContentLayoutConstraint(); childWrapper->Measure(childConstraint); @@ -272,6 +287,21 @@ void UpdateHeightIfMatchPolicy(std::optional layoutPol } } +void ButtonLayoutAlgorithm::LayoutPolicyIsFixAtIdelSize(std::optional layoutPolicy, + const float& topPadding, const float& bottomPadding, SizeF& frameSize) +{ + if (layoutPolicy.has_value()) { + auto heightLayoutPolicy = layoutPolicy.value().heightLayoutPolicy_; + if (heightLayoutPolicy.value_or(LayoutCalPolicy::NO_MATCH) == LayoutCalPolicy::FIX_AT_IDEAL_SIZE) { + if (GreatOrEqual(childSize_.Height() + topPadding + bottomPadding, frameSize.Height())) { + auto actualHeight = childSize_.Height() + topPadding + bottomPadding; + frameSize = SizeF(frameSize.Width(), actualHeight); + } + } + } + return; +} + // Called to perform measure current render node. void ButtonLayoutAlgorithm::PerformMeasureSelf(LayoutWrapper* layoutWrapper) { @@ -312,6 +342,7 @@ void ButtonLayoutAlgorithm::PerformMeasureSelf(LayoutWrapper* layoutWrapper) actualHeight = std::min(actualHeight, maxHeight); actualHeight = std::max(actualHeight, minHeight); frameSize.SetHeight(maxHeight > defaultHeight ? std::max(defaultHeight, actualHeight) : maxHeight); + LayoutPolicyIsFixAtIdelSize(layoutPolicy, topPadding, bottomPadding, frameSize); UpdateHeightIfMatchPolicy(layoutPolicy, frameSize, matchParentHeight); } } diff --git a/frameworks/core/components_ng/pattern/button/button_layout_algorithm.h b/frameworks/core/components_ng/pattern/button/button_layout_algorithm.h index e6fba2e50fde67b9b80de4934f398f4934282915..6927efda6619ad56c72ecbea870c205d99237387 100644 --- a/frameworks/core/components_ng/pattern/button/button_layout_algorithm.h +++ b/frameworks/core/components_ng/pattern/button/button_layout_algorithm.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -49,6 +49,8 @@ private: static float GetDefaultHeight(LayoutWrapper* layoutWrapper); static float GetDefaultBorderRadius(LayoutWrapper* layoutWrapper); bool ProcessLayoutPolicyIsNotNoMatch(std::optional layoutPolicy); + void LayoutPolicyIsFixAtIdelSize(std::optional layoutPolicy, const float& topPadding, + const float& bottomPadding, SizeF& frameSize); SizeF childSize_; ACE_DISALLOW_COPY_AND_MOVE(ButtonLayoutAlgorithm); diff --git a/frameworks/core/components_ng/pattern/checkbox/checkbox_layout_algorithm.cpp b/frameworks/core/components_ng/pattern/checkbox/checkbox_layout_algorithm.cpp index 5aa660b93febcac1735994b316222b16cccbd68f..48f77830fc215d15e3438a815907b0d7e335af5c 100644 --- a/frameworks/core/components_ng/pattern/checkbox/checkbox_layout_algorithm.cpp +++ b/frameworks/core/components_ng/pattern/checkbox/checkbox_layout_algorithm.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -44,11 +44,8 @@ std::optional CheckBoxLayoutAlgorithm::MeasureContent( auto pattern = host->GetPattern(); CHECK_NULL_RETURN(pattern, std::nullopt); if (pattern->UseContentModifier()) { - if (host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN)) { - host->GetGeometryNode()->ResetContent(); - } else { - host->GetGeometryNode()->Reset(); - } + host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN) ? + host->GetGeometryNode()->ResetContent() : host->GetGeometryNode()->Reset(); return std::nullopt; } InitializeParam(host); @@ -57,12 +54,17 @@ std::optional CheckBoxLayoutAlgorithm::MeasureContent( if (layoutPolicy.has_value() && layoutPolicy->IsMatch()) { return LayoutPolicyIsMatchParent(contentConstraint, layoutPolicy, layoutWrapper); } + if (layoutPolicy.has_value() && layoutPolicy->IsFix()) { + return LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicy); + } + if (layoutPolicy.has_value() && layoutPolicy->IsWrap()) { + return LayoutPolicyIsWrapContent(contentConstraint, layoutPolicy); + } // Case 1: Width and height are set in the front end. if (contentConstraint.selfIdealSize.Width().has_value() && contentConstraint.selfIdealSize.Height().has_value() && contentConstraint.selfIdealSize.IsNonNegative()) { - auto height = contentConstraint.selfIdealSize.Height().value(); - auto width = contentConstraint.selfIdealSize.Width().value(); - auto length = std::min(width, height); + auto length = + std::min(contentConstraint.selfIdealSize.Width().value(), contentConstraint.selfIdealSize.Height().value()); return SizeF(length, length); } // Case 2: The front end only sets either width or height @@ -79,9 +81,7 @@ std::optional CheckBoxLayoutAlgorithm::MeasureContent( return SizeF(height, height); } // Case 3: Width and height are not set in the front end, so return from the theme - auto width = defaultWidth_ - 2 * horizontalPadding_; - auto height = defaultHeight_ - 2 * verticalPadding_; - auto size = SizeF(width, height); + auto size = SizeF(defaultWidth_ - 2 * horizontalPadding_, defaultHeight_ - 2 * verticalPadding_); auto padding = GetBorderWidth(layoutWrapper); MinusPaddingToSize(padding, size); size.Constrain(contentConstraint.minSize, contentConstraint.maxSize); @@ -216,6 +216,62 @@ std::optional CheckBoxLayoutAlgorithm::LayoutPolicyIsMatchParent(const La return SizeF(); } +std::optional CheckBoxLayoutAlgorithm::LayoutPolicyIsFixAtIdelSize(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy) +{ + CHECK_NULL_RETURN(layoutPolicy, std::nullopt); + auto selfHeight = contentConstraint.selfIdealSize.Height().value_or(0.0f); + auto selfWidth = contentConstraint.selfIdealSize.Width().value_or(0.0f); + auto defaultLength = std::min(defaultWidth_ - 2 * horizontalPadding_, defaultHeight_ - 2 * verticalPadding_); + auto defaultSize = SizeF(defaultLength, defaultLength); + if (layoutPolicy->IsWidthFix() && layoutPolicy->IsHeightFix()) { + return defaultSize; + } else if (layoutPolicy->IsWidthFix()) { + if (!contentConstraint.selfIdealSize.Height().has_value()) { + return defaultSize; + } + return SizeF(selfHeight, selfHeight); + } else if (layoutPolicy->IsHeightFix()) { + if (!contentConstraint.selfIdealSize.Width().has_value()) { + return defaultSize; + } + return SizeF(selfWidth, selfWidth); + } + return SizeF(); +} + +std::optional CheckBoxLayoutAlgorithm::LayoutPolicyIsWrapContent(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy) +{ + CHECK_NULL_RETURN(layoutPolicy, std::nullopt); + auto height = contentConstraint.parentIdealSize.Height().value_or(0.0f); + auto width = contentConstraint.parentIdealSize.Width().value_or(0.0f); + auto selfHeight = contentConstraint.selfIdealSize.Height().value_or(0.0f); + auto selfWidth = contentConstraint.selfIdealSize.Width().value_or(0.0f); + auto defaultLength = std::min(defaultWidth_ - 2 * horizontalPadding_, defaultHeight_ - 2 * verticalPadding_); + auto defaultSize = SizeF(defaultLength, defaultLength); + auto parentMinLength = std::min(width, height); + if (layoutPolicy->IsWidthWrap() && layoutPolicy->IsHeightWrap()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } else if (layoutPolicy->IsWidthWrap()) { + if (!contentConstraint.selfIdealSize.Height().has_value()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } + auto length = std::min(parentMinLength, selfHeight); + return SizeF(length, length); + } else if (layoutPolicy->IsHeightWrap()) { + if (!contentConstraint.selfIdealSize.Width().has_value()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } + auto length = std::min(parentMinLength, selfWidth); + return SizeF(length, length); + } + return SizeF(); +} + std::optional CheckBoxLayoutAlgorithm::GetLayoutPolicy(LayoutWrapper* layoutWrapper) { auto layoutProperty = layoutWrapper->GetLayoutProperty(); diff --git a/frameworks/core/components_ng/pattern/checkbox/checkbox_layout_algorithm.h b/frameworks/core/components_ng/pattern/checkbox/checkbox_layout_algorithm.h index 409bf554b6c319c97f84e36282d12c6b0e9e84f2..84376c0c5549b0833e9fb0714f75967981dbd283 100644 --- a/frameworks/core/components_ng/pattern/checkbox/checkbox_layout_algorithm.h +++ b/frameworks/core/components_ng/pattern/checkbox/checkbox_layout_algorithm.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -50,6 +50,11 @@ private: std::optional LayoutPolicyIsMatchParent(const LayoutConstraintF& contentConstraint, std::optional layoutPolicy, LayoutWrapper* layoutWrapper); std::optional GetLayoutPolicy(LayoutWrapper* layoutWrapper); + std::optional LayoutPolicyIsFixAtIdelSize(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy); + std::optional LayoutPolicyIsWrapContent(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy); + PaddingPropertyF GetBorderWidth(LayoutWrapper* layoutWrapper); ACE_DISALLOW_COPY_AND_MOVE(CheckBoxLayoutAlgorithm); }; diff --git a/frameworks/core/components_ng/pattern/checkbox/checkbox_pattern.h b/frameworks/core/components_ng/pattern/checkbox/checkbox_pattern.h index 95f241c13f4dfdf73fa09ea4190777055aafe8e3..723b8d3bf05a18aef2d2a83c05bc489bd5c32f8b 100644 --- a/frameworks/core/components_ng/pattern/checkbox/checkbox_pattern.h +++ b/frameworks/core/components_ng/pattern/checkbox/checkbox_pattern.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -177,6 +177,11 @@ public: return true; } + bool IsEnableFix() override + { + return true; + } + private: void OnAttachToFrameNode() override; void OnAttachToFrameNodeMultiThread(const RefPtr& frameNode); diff --git a/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_layout_algorithm.cpp b/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_layout_algorithm.cpp index 123b8c828da7e5665600bca1b43cfad6ff1e667f..141dd52a87de84590a66abab908a2bc425bdd46a 100644 --- a/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_layout_algorithm.cpp +++ b/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_layout_algorithm.cpp @@ -39,6 +39,12 @@ std::optional CheckBoxGroupLayoutAlgorithm::MeasureContent( if (layoutPolicy.has_value() && layoutPolicy->IsMatch()) { return LayoutPolicyIsMatchParent(contentConstraint, layoutPolicy, layoutWrapper); } + if (layoutPolicy.has_value() && layoutPolicy->IsFix()) { + return LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicy); + } + if (layoutPolicy.has_value() && layoutPolicy->IsWrap()) { + return LayoutPolicyIsWrapContent(contentConstraint, layoutPolicy); + } // Case 1: Width and height are set in the front end. if (contentConstraint.selfIdealSize.Width().has_value() && contentConstraint.selfIdealSize.Height().has_value() && @@ -117,6 +123,62 @@ std::optional CheckBoxGroupLayoutAlgorithm::LayoutPolicyIsMatchParent(con return SizeF(); } +std::optional CheckBoxGroupLayoutAlgorithm::LayoutPolicyIsFixAtIdelSize( + const LayoutConstraintF& contentConstraint, std::optional layoutPolicy) +{ + CHECK_NULL_RETURN(layoutPolicy, std::nullopt); + auto selfHeight = contentConstraint.selfIdealSize.Height().value_or(0.0f); + auto selfWidth = contentConstraint.selfIdealSize.Width().value_or(0.0f); + auto defaultLength = std::min(defaultWidth_ - 2 * horizontalPadding_, defaultHeight_ - 2 * verticalPadding_); + auto defaultSize = SizeF(defaultLength, defaultLength); + if (layoutPolicy->IsWidthFix() && layoutPolicy->IsHeightFix()) { + return defaultSize; + } else if (layoutPolicy->IsWidthFix()) { + if (!contentConstraint.selfIdealSize.Height().has_value()) { + return defaultSize; + } + return SizeF(selfHeight, selfHeight); + } else if (layoutPolicy->IsHeightFix()) { + if (!contentConstraint.selfIdealSize.Width().has_value()) { + return defaultSize; + } + return SizeF(selfWidth, selfWidth); + } + return SizeF(); +} + +std::optional CheckBoxGroupLayoutAlgorithm::LayoutPolicyIsWrapContent(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy) +{ + CHECK_NULL_RETURN(layoutPolicy, std::nullopt); + auto height = contentConstraint.parentIdealSize.Height().value_or(0.0f); + auto width = contentConstraint.parentIdealSize.Width().value_or(0.0f); + auto selfHeight = contentConstraint.selfIdealSize.Height().value_or(0.0f); + auto selfWidth = contentConstraint.selfIdealSize.Width().value_or(0.0f); + auto defaultLength = std::min(defaultWidth_ - 2 * horizontalPadding_, defaultHeight_ - 2 * verticalPadding_); + auto defaultSize = SizeF(defaultLength, defaultLength); + auto parentMinLength = std::min(width, height); + if (layoutPolicy->IsWidthWrap() && layoutPolicy->IsHeightWrap()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } else if (layoutPolicy->IsWidthWrap()) { + if (!contentConstraint.selfIdealSize.Height().has_value()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } + auto length = std::min(parentMinLength, selfHeight); + return SizeF(length, length); + } else if (layoutPolicy->IsHeightWrap()) { + if (!contentConstraint.selfIdealSize.Width().has_value()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } + auto length = std::min(parentMinLength, selfWidth); + return SizeF(length, length); + } + return SizeF(); +} + std::optional CheckBoxGroupLayoutAlgorithm::GetLayoutPolicy(LayoutWrapper* layoutWrapper) { auto layoutProperty = layoutWrapper->GetLayoutProperty(); diff --git a/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_layout_algorithm.h b/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_layout_algorithm.h index ce7c85185ce7e2dd1ebb4dfe4e9dc8e828ef6811..f52df56d882fa872d2119ad7c6d5a97b3aaed329 100644 --- a/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_layout_algorithm.h +++ b/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_layout_algorithm.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -48,6 +48,10 @@ private: std::optional LayoutPolicyIsMatchParent(const LayoutConstraintF& contentConstraint, std::optional layoutPolicy, LayoutWrapper* layoutWrapper); std::optional GetLayoutPolicy(LayoutWrapper* layoutWrapper); + std::optional LayoutPolicyIsFixAtIdelSize(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy); + std::optional LayoutPolicyIsWrapContent(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy); ACE_DISALLOW_COPY_AND_MOVE(CheckBoxGroupLayoutAlgorithm); }; diff --git a/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_pattern.h b/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_pattern.h index d636475b467918667dbc9581eea2f5a069b9184f..90ab06298b662bd00ef915b2c994bda6131747e5 100644 --- a/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_pattern.h +++ b/frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_pattern.h @@ -186,6 +186,12 @@ public: { return true; } + + bool IsEnableFix() override + { + return true; + } + void SetBuilderFunc(CheckBoxGroupMakeCallback&& makeFunc) { if (makeFunc == nullptr) { diff --git a/frameworks/core/components_ng/pattern/radio/radio_layout_algorithm.cpp b/frameworks/core/components_ng/pattern/radio/radio_layout_algorithm.cpp index 013cae50a00882759f0703361a784b02a79aa148..5e8fabc5331e0d3182f20c31af84c98084dd2e48 100644 --- a/frameworks/core/components_ng/pattern/radio/radio_layout_algorithm.cpp +++ b/frameworks/core/components_ng/pattern/radio/radio_layout_algorithm.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -33,11 +33,8 @@ std::optional RadioLayoutAlgorithm::MeasureContent( auto pattern = host->GetPattern(); CHECK_NULL_RETURN(pattern, std::nullopt); if (pattern->UseContentModifier()) { - if (host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN)) { - host->GetGeometryNode()->ResetContent(); - } else { - host->GetGeometryNode()->Reset(); - } + host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN) ? host->GetGeometryNode()->ResetContent() + : host->GetGeometryNode()->Reset(); return std::nullopt; } InitializeParam(host); @@ -46,12 +43,17 @@ std::optional RadioLayoutAlgorithm::MeasureContent( realSize_ = LayoutPolicyIsMatchParent(contentConstraint, layoutPolicy, layoutWrapper); return realSize_; } + if (layoutPolicy.has_value() && layoutPolicy->IsFix()) { + return LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicy); + } + if (layoutPolicy.has_value() && layoutPolicy->IsWrap()) { + return LayoutPolicyIsWrapContent(contentConstraint, layoutPolicy); + } // Case 1: Width and height are set in the front end. if (contentConstraint.selfIdealSize.IsValid() && contentConstraint.selfIdealSize.IsNonNegative()) { - auto height = contentConstraint.selfIdealSize.Height().value_or(0.0f); - auto width = contentConstraint.selfIdealSize.Width().value_or(0.0f); - auto length = std::min(width, height); + auto length = std::min(contentConstraint.selfIdealSize.Width().value_or(0.0f), + contentConstraint.selfIdealSize.Height().value_or(0.0f)); return SizeF(length, length); } // Case 2: The front end only sets either width or height @@ -68,9 +70,7 @@ std::optional RadioLayoutAlgorithm::MeasureContent( return SizeF(height, height); } // Case 3: Width and height are not set in the front end, so return from the theme - auto width = defaultWidth_ - 2 * horizontalPadding_; - auto height = defaultHeight_ - 2 * verticalPadding_; - auto size = SizeF(width, height); + auto size = SizeF(defaultWidth_ - 2 * horizontalPadding_, defaultHeight_ - 2 * verticalPadding_); size.Constrain(contentConstraint.minSize, contentConstraint.maxSize); auto padding = layoutWrapper->GetLayoutProperty()->CreatePaddingAndBorder(); MinusPaddingToSize(padding, size); @@ -184,6 +184,62 @@ std::optional RadioLayoutAlgorithm::LayoutPolicyIsMatchParent(const Layou return SizeF(); } +std::optional RadioLayoutAlgorithm::LayoutPolicyIsFixAtIdelSize(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy) +{ + CHECK_NULL_RETURN(layoutPolicy, std::nullopt); + auto selfHeight = contentConstraint.selfIdealSize.Height().value_or(0.0f); + auto selfWidth = contentConstraint.selfIdealSize.Width().value_or(0.0f); + auto defaultLength = defaultWidth_ - 2 * horizontalPadding_; + auto defaultSize = SizeF(defaultLength, defaultLength); + if (layoutPolicy->IsWidthFix() && layoutPolicy->IsHeightFix()) { + return defaultSize; + } else if (layoutPolicy->IsWidthFix()) { + if (!contentConstraint.selfIdealSize.Height().has_value()) { + return defaultSize; + } + return SizeF(selfHeight, selfHeight); + } else if (layoutPolicy->IsHeightFix()) { + if (!contentConstraint.selfIdealSize.Width().has_value()) { + return defaultSize; + } + return SizeF(selfWidth, selfWidth); + } + return SizeF(); +} + +std::optional RadioLayoutAlgorithm::LayoutPolicyIsWrapContent(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy) +{ + CHECK_NULL_RETURN(layoutPolicy, std::nullopt); + auto height = contentConstraint.parentIdealSize.Height().value_or(0.0f); + auto width = contentConstraint.parentIdealSize.Width().value_or(0.0f); + auto selfHeight = contentConstraint.selfIdealSize.Height().value_or(0.0f); + auto selfWidth = contentConstraint.selfIdealSize.Width().value_or(0.0f); + auto defaultLength = defaultWidth_ - 2 * horizontalPadding_; + auto defaultSize = SizeF(defaultLength, defaultLength); + auto parentMinLength = std::min(width, height); + if (layoutPolicy->IsWidthWrap() && layoutPolicy->IsHeightWrap()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } else if (layoutPolicy->IsWidthWrap()) { + if (!contentConstraint.selfIdealSize.Height().has_value()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } + auto length = std::min(parentMinLength, selfHeight); + return SizeF(length, length); + } else if (layoutPolicy->IsHeightWrap()) { + if (!contentConstraint.selfIdealSize.Width().has_value()) { + auto length = std::min(parentMinLength, defaultLength); + return SizeF(length, length); + } + auto length = std::min(parentMinLength, selfWidth); + return SizeF(length, length); + } + return SizeF(); +} + std::optional RadioLayoutAlgorithm::GetLayoutPolicy(LayoutWrapper* layoutWrapper) { auto layoutProperty = layoutWrapper->GetLayoutProperty(); diff --git a/frameworks/core/components_ng/pattern/radio/radio_layout_algorithm.h b/frameworks/core/components_ng/pattern/radio/radio_layout_algorithm.h index 286f20dc26578def456e9ad92730e1d8c6eb9cec..33a17cf97ed9f5a56937d7451817c1fa5d708852 100644 --- a/frameworks/core/components_ng/pattern/radio/radio_layout_algorithm.h +++ b/frameworks/core/components_ng/pattern/radio/radio_layout_algorithm.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -52,6 +52,10 @@ private: std::optional LayoutPolicyIsMatchParent(const LayoutConstraintF& contentConstraint, std::optional layoutPolicy, LayoutWrapper* layoutWrapper); std::optional GetLayoutPolicy(LayoutWrapper* layoutWrapper); + std::optional LayoutPolicyIsFixAtIdelSize(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy); + std::optional LayoutPolicyIsWrapContent(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy); }; } // namespace OHOS::Ace::NG diff --git a/frameworks/core/components_ng/pattern/radio/radio_pattern.h b/frameworks/core/components_ng/pattern/radio/radio_pattern.h index c28bad59882e69fd4bf36b5b6aa51f0e4818fb58..99fc0285395ac5d9d21f386bae1b7bba2ad5572d 100644 --- a/frameworks/core/components_ng/pattern/radio/radio_pattern.h +++ b/frameworks/core/components_ng/pattern/radio/radio_pattern.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -192,6 +192,11 @@ public: return true; } + bool IsEnableFix() override + { + return true; + } + void UpdateRadioComponentColor(const Color& color, const RadioColorType radioColorType); void OnColorConfigurationUpdate() override; void SetUncheckedBorderColorByJSRadioTheme(bool flag) diff --git a/frameworks/core/components_ng/pattern/toggle/switch_layout_algorithm.cpp b/frameworks/core/components_ng/pattern/toggle/switch_layout_algorithm.cpp index 2f773951007f258e741bbc8cf877275cb73dbf9c..349d2ba52c7b11cd57a4183697dbd29bc53e5c07 100644 --- a/frameworks/core/components_ng/pattern/toggle/switch_layout_algorithm.cpp +++ b/frameworks/core/components_ng/pattern/toggle/switch_layout_algorithm.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -28,11 +28,9 @@ std::optional SwitchLayoutAlgorithm::MeasureContent( auto pattern = frameNode->GetPattern(); CHECK_NULL_RETURN(pattern, std::nullopt); if (pattern->UseContentModifier()) { - if (frameNode->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN)) { - frameNode->GetGeometryNode()->ResetContent(); - } else { - frameNode->GetGeometryNode()->Reset(); - } + auto geometryNode = frameNode->GetGeometryNode(); + const bool isApi18OrHigher = frameNode->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN); + isApi18OrHigher ? geometryNode->ResetContent() : geometryNode->Reset(); return std::nullopt; } const auto& layoutProperty = layoutWrapper->GetLayoutProperty(); @@ -65,14 +63,15 @@ std::optional SwitchLayoutAlgorithm::MeasureContent( if (layoutPolicy.has_value() && layoutPolicy->IsMatch()) { LayoutPolicyIsMatchParent(contentConstraint, layoutPolicy, frameWidth, frameHeight); } - float width = 0.0f; - float height = 0.0f; - CalcHeightAndWidth(frameNode, height, width, frameHeight, frameWidth); - - width_ = width; - height_ = height; + if (layoutPolicy.has_value() && layoutPolicy->IsWrap()) { + LayoutPolicyIsWrapContent(contentConstraint, layoutPolicy, frameWidth, frameHeight); + } + if (layoutPolicy.has_value() && layoutPolicy->IsFix()) { + LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicy, frameWidth, frameHeight); + } - return SizeF(width, height); + CalcHeightAndWidth(frameNode, height_, width_, frameHeight, frameWidth); + return SizeF(width_, height_); } void SwitchLayoutAlgorithm::Measure(LayoutWrapper* layoutWrapper) @@ -151,4 +150,35 @@ void SwitchLayoutAlgorithm::LayoutPolicyIsMatchParent(const LayoutConstraintF& c } } } + +void SwitchLayoutAlgorithm::LayoutPolicyIsFixAtIdelSize(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy, float& frameWidth, float& frameHeight) +{ + CHECK_NULL_VOID(layoutPolicy); + auto parentHeight = contentConstraint.parentIdealSize.Height().value_or(0.0f); + auto parentWidth = contentConstraint.parentIdealSize.Width().value_or(0.0f); + if (!layoutPolicy->IsWidthFix()) { + frameWidth = std::min(frameWidth, parentWidth); + } + if (!layoutPolicy->IsHeightFix()) { + frameHeight = std::min(frameHeight, parentHeight); + } + return; +} + +void SwitchLayoutAlgorithm::LayoutPolicyIsWrapContent(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy, float& frameWidth, float& frameHeight) +{ + CHECK_NULL_VOID(layoutPolicy); + auto parentHeight = contentConstraint.parentIdealSize.Height().value_or(0.0f); + auto parentWidth = contentConstraint.parentIdealSize.Width().value_or(0.0f); + + if (layoutPolicy->IsWidthWrap()) { + frameWidth = std::min(frameWidth, parentWidth); + } + if (layoutPolicy->IsHeightWrap()) { + frameHeight = std::min(frameHeight, parentHeight); + } + return; +} } // namespace OHOS::Ace::NG diff --git a/frameworks/core/components_ng/pattern/toggle/switch_layout_algorithm.h b/frameworks/core/components_ng/pattern/toggle/switch_layout_algorithm.h index 3a30197d797a843f673f0265b5bc1568370c8b2f..f0c7570dd8b17eb3f36fe7250eebf885eae4d36f 100644 --- a/frameworks/core/components_ng/pattern/toggle/switch_layout_algorithm.h +++ b/frameworks/core/components_ng/pattern/toggle/switch_layout_algorithm.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -50,6 +50,12 @@ public: void LayoutPolicyIsMatchParent(const LayoutConstraintF& contentConstraint, std::optional layoutPolicy, float& frameWidth, float& frameHeight); + void LayoutPolicyIsFixAtIdelSize(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy, float& frameWidth, float& frameHeight); + + void LayoutPolicyIsWrapContent(const LayoutConstraintF& contentConstraint, + std::optional layoutPolicy, float& frameWidth, float& frameHeight); + private: void CalcHeightAndWidth( const RefPtr& host, float& height, float& width, float frameHeight, float frameWidth); diff --git a/frameworks/core/components_ng/pattern/toggle/switch_pattern.h b/frameworks/core/components_ng/pattern/toggle/switch_pattern.h index 4d719d0620f9175aaa3b6529b6ea85936a29d567..d452a13c2c34626028c3ebc6092651926325d777 100644 --- a/frameworks/core/components_ng/pattern/toggle/switch_pattern.h +++ b/frameworks/core/components_ng/pattern/toggle/switch_pattern.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -154,6 +154,12 @@ public: { return true; } + + bool IsEnableFix() override + { + return true; + } + private: void OnAttachToFrameNode() override; void OnModifyDone() override; diff --git a/test/unittest/core/pattern/button/button_function_test_ng.cpp b/test/unittest/core/pattern/button/button_function_test_ng.cpp index 1d7524a5877da5f8d7a211308dcb4eff45c28334..83737e49264c8a107801384b6ac0731a7e5cec95 100644 --- a/test/unittest/core/pattern/button/button_function_test_ng.cpp +++ b/test/unittest/core/pattern/button/button_function_test_ng.cpp @@ -57,6 +57,8 @@ constexpr float BUTTON_WIDTH = 200.0f; constexpr float BUTTON_HEIGHT = 100.0f; constexpr float FULL_SCREEN_WIDTH = 720.0f; constexpr float FULL_SCREEN_HEIGHT = 1136.0f; +constexpr float TOP_PADDING = 0.0f; +constexpr float BOTTOM_PADDING = 0.0f; constexpr bool STATE_EFFECT = true; const std::string CREATE_VALUE = "Hello World"; const std::string BUTTON_VALUE = "Test"; @@ -1041,6 +1043,150 @@ HWTEST_F(ButtonFunctionTestNg, ButtonFunctionTest012, TestSize.Level1) EXPECT_EQ(childWrapper->GetGeometryNode()->GetContentSize().Height(), 0); } +/** + * @tc.name: ButtonFunctionLayoutPolicyIsFixAtIdelSizeTest001 + * @tc.desc: Test HandleLabelCircleButtonConstraint and ButtonFunctionLayoutPolicyIsFixAtIdelSize. + * @tc.type: FUNC + */ +HWTEST_F(ButtonFunctionTestNg, ButtonFunctionLayoutPolicyIsFixAtIdelSizeTest001, TestSize.Level1) +{ + /** + * @tc.steps: step1. create button and get frameNode. + */ + TestProperty testProperty; + testProperty.typeValue = std::make_optional(ButtonType::CIRCLE); + testProperty.stateEffectValue = std::make_optional(STATE_EFFECT); + auto frameNode = CreateLabelButtonParagraph(CREATE_VALUE, testProperty); + ASSERT_NE(frameNode, nullptr); + + /** + * @tc.steps: step2. get layout property, layoutAlgorithm and create layoutWrapper. + * @tc.expected: step2. related function is called. + */ + auto layoutWrapper = frameNode->CreateLayoutWrapper(); + auto buttonPattern = frameNode->GetPattern(); + ASSERT_NE(buttonPattern, nullptr); + auto buttonLayoutAlgorithm = + AccessibilityManager::DynamicCast(buttonPattern->CreateLayoutAlgorithm()); + ASSERT_NE(buttonLayoutAlgorithm, nullptr); + layoutWrapper->SetLayoutAlgorithm(AccessibilityManager::MakeRefPtr(buttonLayoutAlgorithm)); + + /** + * @tc.steps: step3. update layoutWrapper. + */ + LayoutConstraintF parentLayoutConstraint; + parentLayoutConstraint.maxSize = CONTAINER_SIZE; + parentLayoutConstraint.percentReference = CONTAINER_SIZE; + + PaddingProperty noPadding = CreatePadding(ZERO, ZERO, ZERO, ZERO); + layoutWrapper->GetLayoutProperty()->UpdatePadding(noPadding); + layoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(parentLayoutConstraint); + layoutWrapper->GetLayoutProperty()->UpdateContentConstraint(); + + /** + * @tc.steps: step4. use layoutAlgorithm to call LayoutPolicyIsFixAtIdelSize and + * HandleLabelLayoutPolicyIsFixAtIdelSizeButtonFrameSize. + * @tc.expected: step4. check whether the value of constraint frame szie. + */ + SizeF frameSize; + auto layoutProperty = AccessibilityManager::DynamicCast(layoutWrapper->GetLayoutProperty()); + LayoutPolicyProperty layoutPolicyProperty; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + buttonLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(layoutPolicyProperty, BOTTOM_PADDING, TOP_PADDING, frameSize); + EXPECT_FLOAT_EQ(frameSize.Width(), ZERO); + EXPECT_FLOAT_EQ(frameSize.Height(), ZERO); + + /** + * @tc.steps: step4. use layoutAlgorithm to call LayoutPolicyIsFixAtIdelSize and + * HandleLabelLayoutPolicyIsFixAtIdelSizeButtonFrameSize. + * @tc.expected: step4. check whether the value of constraint frame szie. + */ + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + buttonLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(layoutPolicyProperty, BOTTOM_PADDING, TOP_PADDING, frameSize); + EXPECT_FLOAT_EQ(frameSize.Width(), ZERO); + EXPECT_FLOAT_EQ(frameSize.Height(), ZERO); + + /** + * @tc.steps: step4. use layoutAlgorithm to call LayoutPolicyIsFixAtIdelSize and + * HandleLabelLayoutPolicyIsFixAtIdelSizeButtonFrameSize. + * @tc.expected: step4. check whether the value of constraint frame szie. + */ + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + buttonLayoutAlgorithm->childSize_.SetHeight(ZERO); + buttonLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(layoutPolicyProperty, BOTTOM_PADDING, TOP_PADDING, frameSize); + EXPECT_FLOAT_EQ(frameSize.Width(), ZERO); + EXPECT_FLOAT_EQ(frameSize.Height(), ZERO); + + /** + * @tc.steps: step4. use layoutAlgorithm to call LayoutPolicyIsFixAtIdelSize and + * HandleLabelLayoutPolicyIsFixAtIdelSizeButtonFrameSize. + * @tc.expected: step4. check whether the value of constraint frame szie. + */ + buttonLayoutAlgorithm->childSize_.SetHeight(BUTTON_HEIGHT); + buttonLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(layoutPolicyProperty, BOTTOM_PADDING, TOP_PADDING, frameSize); + EXPECT_FLOAT_EQ(frameSize.Width(), ZERO); +} + +/** + * @tc.name: ButtonFunctionHandleAdaptiveTextTest001 + * @tc.desc: test button layout using buttonType ROUNDED_RECTANGLE and Handle Adaptive Text. + * @tc.type: FUNC + */ +HWTEST_F(ButtonFunctionTestNg, ButtonFunctionHandleAdaptiveTextTest001, TestSize.Level1) +{ + /** + * @tc.steps: step1. create bubble and get frameNode. + */ + TestProperty testProperty; + testProperty.typeValue = std::make_optional(ButtonType::ROUNDED_RECTANGLE); + testProperty.stateEffectValue = std::make_optional(STATE_EFFECT); + testProperty.borderRadius = std::make_optional(BORDER_RADIUS); + auto frameNode = CreateLabelButtonParagraphByRoundedRect(CREATE_VALUE, testProperty); + ASSERT_NE(frameNode, nullptr); + + /** + * @tc.steps: step2. get layout property, layoutAlgorithm and create layoutWrapper. + * @tc.expected: step2. related function is called. + */ + RefPtr geometryNode = AceType::MakeRefPtr(); + ASSERT_NE(geometryNode, nullptr); + auto layoutWrapper = frameNode->CreateLayoutWrapper(); + auto buttonPattern = frameNode->GetPattern(); + ASSERT_NE(buttonPattern, nullptr); + auto buttonLayoutAlgorithm = buttonPattern->CreateLayoutAlgorithm(); + ASSERT_NE(buttonLayoutAlgorithm, nullptr); + layoutWrapper->SetLayoutAlgorithm(AccessibilityManager::MakeRefPtr(buttonLayoutAlgorithm)); + + /** + * @tc.steps: step3. update layoutWrapper. + */ + // set button width and height by user + layoutWrapper->GetLayoutProperty()->UpdateUserDefinedIdealSize(CalcSize(CalcLength(BUTTON_WIDTH), CalcLength())); + LayoutConstraintF parentLayoutConstraint; + parentLayoutConstraint.maxSize = CONTAINER_SIZE; + parentLayoutConstraint.percentReference = CONTAINER_SIZE; + + PaddingProperty noPadding = CreatePadding(ZERO, ZERO, ZERO, ZERO); + layoutWrapper->GetLayoutProperty()->UpdatePadding(noPadding); + layoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(parentLayoutConstraint); + layoutWrapper->GetLayoutProperty()->UpdateContentConstraint(); + + /** + * @tc.steps: step3. use layoutAlgorithm to measure and layout. + * @tc.expected: check whether the value of geometry's frameSize and frameOffset is correct. + */ + buttonLayoutAlgorithm->Measure(AccessibilityManager::RawPtr(layoutWrapper)); + buttonLayoutAlgorithm->Layout(AccessibilityManager::RawPtr(layoutWrapper)); + EXPECT_FLOAT_EQ(layoutWrapper->GetGeometryNode()->GetFrameSize().Width(), BUTTON_WIDTH); + EXPECT_EQ(layoutWrapper->GetGeometryNode()->GetFrameOffset(), OffsetF()); + + layoutWrapper->GetLayoutProperty()->UpdateLayoutPolicyProperty(LayoutCalPolicy::FIX_AT_IDEAL_SIZE, true); + buttonLayoutAlgorithm->Measure(AccessibilityManager::RawPtr(layoutWrapper)); + buttonLayoutAlgorithm->Layout(AccessibilityManager::RawPtr(layoutWrapper)); + EXPECT_FLOAT_EQ(layoutWrapper->GetGeometryNode()->GetFrameSize().Width(), BUTTON_WIDTH); + EXPECT_EQ(layoutWrapper->GetGeometryNode()->GetFrameOffset(), OffsetF()); +} + /** * @tc.name: ButtonFunctionTest013 * @tc.desc: Test on color configuration update diff --git a/test/unittest/core/pattern/checkbox/BUILD.gn b/test/unittest/core/pattern/checkbox/BUILD.gn index aace05194f6917be6364b22ed8702d30ea17d174..761d463500df1f529319a1604587b6edc2f4f4a8 100644 --- a/test/unittest/core/pattern/checkbox/BUILD.gn +++ b/test/unittest/core/pattern/checkbox/BUILD.gn @@ -21,6 +21,7 @@ ace_unittest("checkbox_test_ng") { "checkbox_pattern_test_ng.cpp", "checkbox_patternScd_test_ng.cpp", "checkbox_test_ng.cpp", + "checkbox_sub_test_ng.cpp", "checkbox_model_static_test_ng.cpp", ] } diff --git a/test/unittest/core/pattern/checkbox/checkbox_sub_test_ng.cpp b/test/unittest/core/pattern/checkbox/checkbox_sub_test_ng.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e00cb8e08f70ceceef3e49e706ad740114aafb12 --- /dev/null +++ b/test/unittest/core/pattern/checkbox/checkbox_sub_test_ng.cpp @@ -0,0 +1,368 @@ +/* + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "gtest/gtest.h" + +// Add the following two macro definitions to test the private and protected method. +#define private public +#define protected public +#include "core/components/checkable/checkable_theme.h" +#include "core/components_ng/base/view_abstract.h" +#include "core/components_ng/base/view_stack_processor.h" +#include "core/components_ng/pattern/checkbox/checkbox_accessibility_property.h" +#include "core/components_ng/pattern/checkbox/checkbox_model_ng.h" +#include "core/components_ng/pattern/checkbox/checkbox_paint_property.h" +#include "core/components_ng/pattern/checkbox/checkbox_pattern.h" +#include "core/components_ng/pattern/checkboxgroup/checkboxgroup_model_ng.h" +#include "core/components_ng/pattern/checkboxgroup/checkboxgroup_paint_property.h" +#include "core/components_ng/pattern/checkboxgroup/checkboxgroup_pattern.h" +#include "core/components_ng/pattern/linear_layout/column_model_ng.h" +#include "core/components_ng/pattern/stage/page_event_hub.h" +#include "core/components_ng/pattern/stage/stage_manager.h" +#include "core/components_ng/pattern/stage/stage_pattern.h" +#include "test/mock/core/rosen/mock_canvas.h" +#include "test/mock/core/common/mock_theme_manager.h" +#include "core/pipeline_ng/pipeline_context.h" +#include "test/mock/core/pipeline/mock_pipeline_context.h" +#include "test/mock/core/common/mock_container.h" + +using namespace testing; +using namespace testing::ext; +using CheckboxBuilderFunc = std::optional>; + +namespace OHOS::Ace::NG { +namespace { +const std::string NAME = "checkbox"; +const std::string GROUP_NAME = "checkboxGroup"; +const std::string TAG = "CHECKBOX_TAG"; +RefPtr pipeline = nullptr; +const SizeF TEST_SIZE_0 = SizeF(0.0f, 0.0f); +const SizeF TEST_SIZE_100_200 = SizeF(100.0f, 200.0f); +const SizeF TEST_SIZE_100 = SizeF(100.0f, 100.0f); +const SizeF TEST_SIZE_200 = SizeF(200.0f, 200.0f); +const SizeF TEST_SIZE_60 = SizeF(60.0f, 60.0f); +constexpr float TEST_HORIZONPADDING = 5.0f; +constexpr float TEST_HEIGHT_60 = 60.0f; +} // namespace + +class CheckBoxSubTestNG : public testing::Test { +public: + static void SetUpTestSuite(); + static void TearDownTestSuite(); + CheckboxBuilderFunc CheckboxBuilder(); +}; + +void CheckBoxSubTestNG::SetUpTestSuite() +{ + MockPipelineContext::SetUp(); + auto themeManager = AceType::MakeRefPtr(); + MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr())); + EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(AceType::MakeRefPtr())); + + RefPtr stageNode = AceType::MakeRefPtr("STAGE", -1, AceType::MakeRefPtr()); + auto stageManager = AceType::MakeRefPtr(stageNode); + MockPipelineContext::GetCurrent()->stageManager_ = stageManager; +} + +void CheckBoxSubTestNG::TearDownTestSuite() +{ + MockPipelineContext::TearDown(); +} + +CheckboxBuilderFunc CheckBoxSubTestNG::CheckboxBuilder() +{ + return []() { + ColumnModelNG colModel; + colModel.Create(Dimension(0), nullptr, ""); + ViewAbstract::SetWidth(CalcLength(10.f)); + ViewAbstract::SetHeight(CalcLength(10.f)); + }; +} + +/** + * @tc.name: CheckBoxMeasureTest138 + * @tc.desc: Test CheckBox MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(CheckBoxSubTestNG, CheckBoxMeasureTest138, TestSize.Level1) +{ + /** + * @tc.steps: step1. Init CheckBox node. + */ + CheckBoxModelNG checkBoxModelNG; + checkBoxModelNG.Create(NAME, GROUP_NAME, TAG); + auto frameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + ASSERT_NE(frameNode, nullptr); + + /** + * @tc.steps: create mock theme manager, set checkbox theme + */ + auto themeManager = AceType::MakeRefPtr(); + auto pipeline = MockPipelineContext::GetCurrent(); + pipeline->SetThemeManager(themeManager); + auto checkboxTheme = AceType::MakeRefPtr(); + checkboxTheme->defaultWidth_ = Dimension(TEST_HEIGHT_60); + checkboxTheme->defaultPaddingSize_ = Dimension(TEST_HORIZONPADDING); + checkboxTheme->hotZoneHorizontalPadding_ = Dimension(TEST_HORIZONPADDING); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme)); + + /** + * @tc.steps: step2. Create LayoutWrapperNode and set checkBoxLayoutAlgorithm. + */ + RefPtr geometryNode = AceType::MakeRefPtr(); + ASSERT_NE(geometryNode, nullptr); + LayoutWrapperNode layoutWrapper = LayoutWrapperNode(frameNode, geometryNode, frameNode->GetLayoutProperty()); + auto checkBoxPattern = frameNode->GetPattern(); + ASSERT_NE(checkBoxPattern, nullptr); + auto checkBoxLayoutAlgorithm = + AceType::DynamicCast(checkBoxPattern->CreateLayoutAlgorithm()); + ASSERT_NE(checkBoxLayoutAlgorithm, nullptr); + layoutWrapper.SetLayoutAlgorithm(AceType::MakeRefPtr(checkBoxLayoutAlgorithm)); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to FIX_AT_IDEAL_SIZE. + * @tc.expected: step3. switchSize is equal to TEST_SIZE_100. + */ + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + auto ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_100_200); + ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_200); +} + +/** + * @tc.name: CheckBoxMeasureTest139 + * @tc.desc: Test CheckBox MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(CheckBoxSubTestNG, CheckBoxMeasureTest139, TestSize.Level1) +{ + /** + * @tc.steps: step1. Init CheckBox node. + */ + CheckBoxModelNG checkBoxModelNG; + checkBoxModelNG.Create(NAME, GROUP_NAME, TAG); + auto frameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + ASSERT_NE(frameNode, nullptr); + + /** + * @tc.steps: create mock theme manager, set checkbox theme + */ + auto themeManager = AceType::MakeRefPtr(); + auto pipeline = MockPipelineContext::GetCurrent(); + pipeline->SetThemeManager(themeManager); + auto checkboxTheme = AceType::MakeRefPtr(); + checkboxTheme->defaultWidth_ = Dimension(TEST_HEIGHT_60); + checkboxTheme->defaultPaddingSize_ = Dimension(TEST_HORIZONPADDING); + checkboxTheme->hotZoneHorizontalPadding_ = Dimension(TEST_HORIZONPADDING); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme)); + + /** + * @tc.steps: step2. Create LayoutWrapperNode and set checkBoxLayoutAlgorithm. + */ + RefPtr geometryNode = AceType::MakeRefPtr(); + ASSERT_NE(geometryNode, nullptr); + LayoutWrapperNode layoutWrapper = LayoutWrapperNode(frameNode, geometryNode, frameNode->GetLayoutProperty()); + auto checkBoxPattern = frameNode->GetPattern(); + ASSERT_NE(checkBoxPattern, nullptr); + auto checkBoxLayoutAlgorithm = + AceType::DynamicCast(checkBoxPattern->CreateLayoutAlgorithm()); + ASSERT_NE(checkBoxLayoutAlgorithm, nullptr); + layoutWrapper.SetLayoutAlgorithm(AceType::MakeRefPtr(checkBoxLayoutAlgorithm)); + + /** + * @tc.steps: step3. set heightLayoutPolicy_ to FIX_AT_IDEAL_SIZE. + */ + LayoutConstraintF contentConstraint; + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_100_200); + ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_100); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to NO_MATCH. + */ + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = checkBoxLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicyProperty); + EXPECT_EQ(ret, TEST_SIZE_0); +} + + +/** + * @tc.name: CheckBoxMeasureTest140 + * @tc.desc: Test CheckBox MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(CheckBoxSubTestNG, CheckBoxMeasureTest140, TestSize.Level1) +{ + /** + * @tc.steps: step1. Init CheckBox node. + */ + CheckBoxModelNG checkBoxModelNG; + checkBoxModelNG.Create(NAME, GROUP_NAME, TAG); + auto frameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + ASSERT_NE(frameNode, nullptr); + + /** + * @tc.steps: create mock theme manager, set checkbox theme + */ + auto themeManager = AceType::MakeRefPtr(); + auto pipeline = MockPipelineContext::GetCurrent(); + pipeline->SetThemeManager(themeManager); + auto checkboxTheme = AceType::MakeRefPtr(); + checkboxTheme->defaultWidth_ = Dimension(TEST_HEIGHT_60); + checkboxTheme->defaultPaddingSize_ = Dimension(TEST_HORIZONPADDING); + checkboxTheme->hotZoneHorizontalPadding_ = Dimension(TEST_HORIZONPADDING); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme)); + + /** + * @tc.steps: step2. Create LayoutWrapperNode and set checkBoxLayoutAlgorithm. + */ + RefPtr geometryNode = AceType::MakeRefPtr(); + ASSERT_NE(geometryNode, nullptr); + LayoutWrapperNode layoutWrapper = LayoutWrapperNode(frameNode, geometryNode, frameNode->GetLayoutProperty()); + auto checkBoxPattern = frameNode->GetPattern(); + ASSERT_NE(checkBoxPattern, nullptr); + auto checkBoxLayoutAlgorithm = + AceType::DynamicCast(checkBoxPattern->CreateLayoutAlgorithm()); + ASSERT_NE(checkBoxLayoutAlgorithm, nullptr); + layoutWrapper.SetLayoutAlgorithm(AceType::MakeRefPtr(checkBoxLayoutAlgorithm)); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to WRAP_CONTENT. + * @tc.expected: step3. switchSize is equal to TEST_SIZE_100. + */ + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + auto ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_60); + ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_60); +} + +/** + * @tc.name: CheckBoxMeasureTest141 + * @tc.desc: Test CheckBox MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(CheckBoxSubTestNG, CheckBoxMeasureTest141, TestSize.Level1) +{ + /** + * @tc.steps: step1. Init CheckBox node. + */ + CheckBoxModelNG checkBoxModelNG; + checkBoxModelNG.Create(NAME, GROUP_NAME, TAG); + auto frameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + ASSERT_NE(frameNode, nullptr); + + /** + * @tc.steps: create mock theme manager, set checkbox theme + */ + auto themeManager = AceType::MakeRefPtr(); + auto pipeline = MockPipelineContext::GetCurrent(); + pipeline->SetThemeManager(themeManager); + auto checkboxTheme = AceType::MakeRefPtr(); + checkboxTheme->defaultWidth_ = Dimension(TEST_HEIGHT_60); + checkboxTheme->defaultPaddingSize_ = Dimension(TEST_HORIZONPADDING); + checkboxTheme->hotZoneHorizontalPadding_ = Dimension(TEST_HORIZONPADDING); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(checkboxTheme)); + + /** + * @tc.steps: step2. Create LayoutWrapperNode and set checkBoxLayoutAlgorithm. + */ + RefPtr geometryNode = AceType::MakeRefPtr(); + ASSERT_NE(geometryNode, nullptr); + LayoutWrapperNode layoutWrapper = LayoutWrapperNode(frameNode, geometryNode, frameNode->GetLayoutProperty()); + auto checkBoxPattern = frameNode->GetPattern(); + ASSERT_NE(checkBoxPattern, nullptr); + auto checkBoxLayoutAlgorithm = + AceType::DynamicCast(checkBoxPattern->CreateLayoutAlgorithm()); + ASSERT_NE(checkBoxLayoutAlgorithm, nullptr); + layoutWrapper.SetLayoutAlgorithm(AceType::MakeRefPtr(checkBoxLayoutAlgorithm)); + + /** + * @tc.steps: step3. set heightLayoutPolicy_ to WRAP_CONTENT. + */ + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + + auto ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_60); + ret = checkBoxLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_60); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to NO_MATCH. + */ + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = checkBoxLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicyProperty); + EXPECT_EQ(ret, TEST_SIZE_0); +} +} // namespace OHOS::Ace::NG diff --git a/test/unittest/core/pattern/checkboxgroup/checkboxgroup_test_ng.cpp b/test/unittest/core/pattern/checkboxgroup/checkboxgroup_test_ng.cpp index e1e626c31b6c69d24311f3f5bb505aa651a0b20e..ef67257147960820937dbe20eae9914cb3c59bb7 100644 --- a/test/unittest/core/pattern/checkboxgroup/checkboxgroup_test_ng.cpp +++ b/test/unittest/core/pattern/checkboxgroup/checkboxgroup_test_ng.cpp @@ -101,10 +101,12 @@ const SizeF TEST_SIZE_0 = SizeF(0.0f, 0.0f); const SizeF TEST_SIZE_100_200 = SizeF(100.0f, 200.0f); const SizeF TEST_SIZE_100 = SizeF(100.0f, 100.0f); const SizeF TEST_SIZE_200 = SizeF(200.0f, 200.0f); +const SizeF TEST_SIZE_40 = SizeF(40.0f, 40.0f); const SizeF TEST_SIZE_50 = SizeF(50.0f, 50.0f); const SizeF TEST_SIZE_60 = SizeF(60.0f, 60.0f); constexpr float TEST_WIDTH_50 = 50.0f; constexpr float TEST_HEIGHT_60 = 60.0f; +constexpr float TEST_HORIZONPADDING = 5.0f; } // namespace class CheckBoxGroupTestNG : public testing::Test { @@ -2237,6 +2239,209 @@ HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupMeasureContentTest001, TestSize.Level EXPECT_EQ(ret, TEST_SIZE_100); } +/** + * @tc.name: CheckBoxGroupMeasureContentTest002 + * @tc.desc: Test CheckBoxGroup MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupMeasureContentTest002, TestSize.Level1) +{ + /** + * @tc.steps: step1. Create CheckBoxGroupLayoutAlgorithm. + * @tc.expected: Create successfully. + */ + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(nullptr, nullptr, AccessibilityManager::MakeRefPtr()); + auto checkBoxGroupLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(checkBoxGroupLayoutAlgorithm, nullptr); + + /** + * @tc.steps: step2. set widthLayoutPolicy_ and heightLayoutPolicy_ to MATCH_PARENT. + * @tc.expected: ret is equal to TEST_SIZE_100. + */ + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_50); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_HEIGHT_60; + checkBoxGroupLayoutAlgorithm->horizontalPadding_ = TEST_HORIZONPADDING; + auto ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_50); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_WIDTH_50; + checkBoxGroupLayoutAlgorithm->defaultHeight_ = TEST_HEIGHT_60; + ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_100_200); + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_WIDTH_50; + checkBoxGroupLayoutAlgorithm->defaultHeight_ = TEST_HEIGHT_60; + ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); +} + +/** + * @tc.name: CheckBoxGroupMeasureContentTest003 + * @tc.desc: Test CheckBoxGroup MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupMeasureContentTest003, TestSize.Level1) +{ + /** + * @tc.steps: step1. Create CheckBoxGroupLayoutAlgorithm. + * @tc.expected: Create successfully. + */ + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(nullptr, nullptr, AccessibilityManager::MakeRefPtr()); + auto checkBoxGroupLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(checkBoxGroupLayoutAlgorithm, nullptr); + + /** + * @tc.steps: step2. set widthLayoutPolicy_ and heightLayoutPolicy_ to MATCH_PARENT. + * @tc.expected: ret is equal to TEST_SIZE_100. + */ + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_50); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_HEIGHT_60; + checkBoxGroupLayoutAlgorithm->horizontalPadding_ = TEST_HORIZONPADDING; + auto ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_50); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_100_200); + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_WIDTH_50; + checkBoxGroupLayoutAlgorithm->defaultHeight_ = TEST_HEIGHT_60; + ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_WIDTH_50; + checkBoxGroupLayoutAlgorithm->defaultHeight_ = TEST_HEIGHT_60; + ret = checkBoxGroupLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicyProperty); + EXPECT_NE(ret, TEST_SIZE_200); +} + +/** + * @tc.name: CheckBoxGroupMeasureContentTest004 + * @tc.desc: Test CheckBoxGroup MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupMeasureContentTest004, TestSize.Level1) +{ + /** + * @tc.steps: step1. Create CheckBoxGroupLayoutAlgorithm. + * @tc.expected: Create successfully. + */ + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(nullptr, nullptr, AccessibilityManager::MakeRefPtr()); + auto checkBoxGroupLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(checkBoxGroupLayoutAlgorithm, nullptr); + + /** + * @tc.steps: step2. set widthLayoutPolicy_ and heightLayoutPolicy_ to WRAP_CONTENT. + */ + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_HEIGHT_60; + checkBoxGroupLayoutAlgorithm->horizontalPadding_ = TEST_HORIZONPADDING; + auto ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_WIDTH_50; + checkBoxGroupLayoutAlgorithm->defaultHeight_ = TEST_HEIGHT_60; + ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_60); + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_WIDTH_50; + checkBoxGroupLayoutAlgorithm->defaultHeight_ = TEST_HEIGHT_60; + ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); +} + +/** + * @tc.name: CheckBoxGroupMeasureContentTest005 + * @tc.desc: Test CheckBoxGroup MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(CheckBoxGroupTestNG, CheckBoxGroupMeasureContentTest005, TestSize.Level1) +{ + /** + * @tc.steps: step1. Create CheckBoxGroupLayoutAlgorithm. + * @tc.expected: Create successfully. + */ + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(nullptr, nullptr, AccessibilityManager::MakeRefPtr()); + auto checkBoxGroupLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(checkBoxGroupLayoutAlgorithm, nullptr); + + /** + * @tc.steps: step2. set widthLayoutPolicy_ and heightLayoutPolicy_ to MATCH_PARENT. + * @tc.expected: ret is equal to TEST_SIZE_100. + */ + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_HEIGHT_60; + checkBoxGroupLayoutAlgorithm->horizontalPadding_ = TEST_HORIZONPADDING; + auto ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_60); + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_WIDTH_50; + checkBoxGroupLayoutAlgorithm->defaultHeight_ = TEST_HEIGHT_60; + ret = checkBoxGroupLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(ret, TEST_SIZE_200); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + checkBoxGroupLayoutAlgorithm->defaultWidth_ = TEST_WIDTH_50; + checkBoxGroupLayoutAlgorithm->defaultHeight_ = TEST_HEIGHT_60; + ret = checkBoxGroupLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicyProperty); + EXPECT_NE(ret, TEST_SIZE_200); +} + /** * @tc.name: CheckBoxGroupLayoutPolicyIsMatchParentTest001 * @tc.desc: Test CheckBoxGroup LayoutPolicyIsMatchParent. diff --git a/test/unittest/core/pattern/radio/radio_test_ng.cpp b/test/unittest/core/pattern/radio/radio_test_ng.cpp index 25b414e523cad17d297b6705229d64dcc8de286e..9b6027c12bbfd12eb3fffeca974edc1ae3c17037 100644 --- a/test/unittest/core/pattern/radio/radio_test_ng.cpp +++ b/test/unittest/core/pattern/radio/radio_test_ng.cpp @@ -80,6 +80,7 @@ const SizeF TEST_SIZE_50 = SizeF(50.0f, 50.0f); const SizeF TEST_SIZE_60 = SizeF(60.0f, 60.0f); constexpr float TEST_WIDTH_50 = 50.0f; constexpr float TEST_HEIGHT_60 = 60.0f; +constexpr float TEST_HORIZONPADDING = 5.0f; } // namespace class RadioTestNg : public TestNG { @@ -2451,6 +2452,214 @@ HWTEST_F(RadioTestNg, MeasureContentTest001, TestSize.Level1) EXPECT_EQ(ret, TEST_SIZE_100); } +/** + * @tc.name: MeasureContentTest002 + * @tc.desc: Test Radio MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(RadioTestNg, MeasureContentTest002, TestSize.Level1) +{ + /** + * @tc.steps: step1. set widthLayoutPolicy_ and heightLayoutPolicy_ to FIX_AT_IDEAL_SIZE. + * @tc.expected: ret is equal to TEST_SIZE_100. + */ + RadioModelNG radioModelNG; + radioModelNG.Create(std::nullopt, std::nullopt, std::nullopt); + auto frameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(frameNode, nullptr, AccessibilityManager::MakeRefPtr()); + + /** + * @tc.steps: create mock theme manager, set radioTheme + */ + auto themeManager = AceType::MakeRefPtr(); + auto pipeline = MockPipelineContext::GetCurrent(); + pipeline->SetThemeManager(themeManager); + auto radioTheme = AceType::MakeRefPtr(); + radioTheme->width_ = Dimension(TEST_HEIGHT_60); + radioTheme->defaultPaddingSize_ = Dimension(TEST_HORIZONPADDING); + radioTheme->hotZoneHorizontalPadding_ = Dimension(TEST_HORIZONPADDING); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(radioTheme)); + + RadioLayoutAlgorithm radioLayoutAlgorithm; + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + auto ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_50); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_50); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_100_200); + ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_200); +} + +/** + * @tc.name: MeasureContentTest003 + * @tc.desc: Test Radio MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(RadioTestNg, MeasureContentTest003, TestSize.Level1) +{ + /** + * @tc.steps: step1. set widthLayoutPolicy_ and heightLayoutPolicy_ to FIX_AT_IDEAL_SIZE. + * @tc.expected: ret is equal to TEST_SIZE_100. + */ + RadioModelNG radioModelNG; + radioModelNG.Create(std::nullopt, std::nullopt, std::nullopt); + auto frameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(frameNode, nullptr, AccessibilityManager::MakeRefPtr()); + + /** + * @tc.steps: create mock theme manager, set radioTheme + */ + auto themeManager = AceType::MakeRefPtr(); + auto pipeline = MockPipelineContext::GetCurrent(); + pipeline->SetThemeManager(themeManager); + auto radioTheme = AceType::MakeRefPtr(); + radioTheme->width_ = Dimension(TEST_HEIGHT_60); + radioTheme->defaultPaddingSize_ = Dimension(TEST_HORIZONPADDING); + radioTheme->hotZoneHorizontalPadding_ = Dimension(TEST_HORIZONPADDING); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(radioTheme)); + + RadioLayoutAlgorithm radioLayoutAlgorithm; + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + auto ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_50); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_100_200); + ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_100); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = radioLayoutAlgorithm.LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicyProperty); + EXPECT_EQ(ret, TEST_SIZE_0); +} + +/** + * @tc.name: MeasureContentTest004 + * @tc.desc: Test Radio MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(RadioTestNg, MeasureContentTest004, TestSize.Level1) +{ + /** + * @tc.steps: step1. set widthLayoutPolicy_ and heightLayoutPolicy_ to MATCH_PARENT. + * @tc.expected: ret is equal to TEST_SIZE_100. + */ + RadioModelNG radioModelNG; + radioModelNG.Create(std::nullopt, std::nullopt, std::nullopt); + auto frameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(frameNode, nullptr, AccessibilityManager::MakeRefPtr()); + + /** + * @tc.steps: create mock theme manager, set radioTheme + */ + auto themeManager = AceType::MakeRefPtr(); + auto pipeline = MockPipelineContext::GetCurrent(); + pipeline->SetThemeManager(themeManager); + auto radioTheme = AceType::MakeRefPtr(); + radioTheme->width_ = Dimension(TEST_HEIGHT_60); + radioTheme->defaultPaddingSize_ = Dimension(TEST_HORIZONPADDING); + radioTheme->hotZoneHorizontalPadding_ = Dimension(TEST_HORIZONPADDING); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(radioTheme)); + + RadioLayoutAlgorithm radioLayoutAlgorithm; + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + auto ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_50); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_50); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_60); + ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_60); +} + +/** + * @tc.name: MeasureContentTest005 + * @tc.desc: Test Radio MeasureContent. + * @tc.type: FUNC + */ +HWTEST_F(RadioTestNg, MeasureContentTest005, TestSize.Level1) +{ + /** + * @tc.steps: step1. set widthLayoutPolicy_ and heightLayoutPolicy_ to MATCH_PARENT. + * @tc.expected: ret is equal to TEST_SIZE_100. + */ + RadioModelNG radioModelNG; + radioModelNG.Create(std::nullopt, std::nullopt, std::nullopt); + auto frameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(frameNode, nullptr, AccessibilityManager::MakeRefPtr()); + + /** + * @tc.steps: create mock theme manager, set radioTheme + */ + auto themeManager = AceType::MakeRefPtr(); + auto pipeline = MockPipelineContext::GetCurrent(); + pipeline->SetThemeManager(themeManager); + auto radioTheme = AceType::MakeRefPtr(); + radioTheme->width_ = Dimension(TEST_HEIGHT_60); + radioTheme->defaultPaddingSize_ = Dimension(TEST_HORIZONPADDING); + radioTheme->hotZoneHorizontalPadding_ = Dimension(TEST_HORIZONPADDING); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(radioTheme)); + + RadioLayoutAlgorithm radioLayoutAlgorithm; + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_SIZE_100_200); + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + auto ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_50); + + contentConstraint.selfIdealSize.SetSize(TEST_SIZE_60); + ret = radioLayoutAlgorithm.MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(ret, TEST_SIZE_60); + + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + ret = radioLayoutAlgorithm.LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicyProperty); + EXPECT_EQ(ret, TEST_SIZE_0); +} + /** * @tc.name: LayoutPolicyIsMatchParentTest001 * @tc.desc: Test Radio LayoutPolicyIsMatchParent. diff --git a/test/unittest/core/pattern/toggle/toggle_switch_test_ng.cpp b/test/unittest/core/pattern/toggle/toggle_switch_test_ng.cpp index 43dc612786a2b110fa3ee2d2c7e6e3c0735331b8..04a247216d361f65aea5818bff40f1f340acb5ee 100644 --- a/test/unittest/core/pattern/toggle/toggle_switch_test_ng.cpp +++ b/test/unittest/core/pattern/toggle/toggle_switch_test_ng.cpp @@ -58,6 +58,7 @@ constexpr float USER_DEFINE_WIDTH = 180.0f; constexpr float USER_DEFINE_HEIGHT = 100.0f; const SizeF CONTAINER_SIZE(CONTAINER_WIDTH, CONTAINER_HEIGHT); const SizeF TEST_CONTAINER_SIZE(200.0f, 200.0f); +const SizeF TEST_CONTAINER_SIZE0(0.0f, 0.0f); constexpr float TEST_ZERO = 0.0f; } // namespace @@ -1748,6 +1749,296 @@ HWTEST_F(ToggleSwitchTestNg, ToggleSwitchLayoutTest014, TestSize.Level1) MockContainer::Current()->SetApiTargetVersion(rollbackApiVersion); } +/** + * @tc.name: ToggleFixIdealSizeTest001 + * @tc.desc: Test toggle switch fixIdealSize. + * @tc.type: FUNC + */ +HWTEST_F(ToggleSwitchTestNg, ToggleFixIdealSizeTest001, TestSize.Level1) +{ + int32_t rollbackApiVersion = MockContainer::Current()->GetApiTargetVersion(); + int32_t setApiVersion = static_cast(PlatformVersion::VERSION_TWELVE); + MockContainer::Current()->SetApiTargetVersion(setApiVersion); + + /** + * @tc.steps: step1. create switch and get frameNode. + */ + ToggleModelNG toggleModelNG; + toggleModelNG.Create(ToggleType::SWITCH, IS_ON); + auto switchFrameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + EXPECT_NE(switchFrameNode, nullptr); + + /** + * @tc.steps: step2. get switchPattern and switchWrapper. + * @tc.expected: step2. get switchPattern success. + */ + auto switchPattern = AceType::DynamicCast(switchFrameNode->GetPattern()); + EXPECT_NE(switchPattern, nullptr); + RefPtr geometryNode = AceType::MakeRefPtr(); + EXPECT_NE(switchFrameNode, nullptr); + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(switchFrameNode, geometryNode, switchFrameNode->GetLayoutProperty()); + auto switchLayoutAlgorithm = AceType::DynamicCast(switchPattern->CreateLayoutAlgorithm()); + EXPECT_NE(switchLayoutAlgorithm, nullptr); + layoutWrapper.SetLayoutAlgorithm(AccessibilityManager::MakeRefPtr(switchLayoutAlgorithm)); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to null. + * @tc.expected: step3. switchSize is not equal to TEST_CONTAINER_SIZE. + */ + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_CONTAINER_SIZE); + auto switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(switchSize, TEST_CONTAINER_SIZE); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to FIX_AT_IDEAL_SIZE,FIX_AT_IDEAL_SIZE. + * @tc.expected: step3. switchSize is not equal to TEST_CONTAINER_SIZE. + */ + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(switchSize, TEST_CONTAINER_SIZE); + + /** + * @tc.steps: step4. set widthLayoutPolicy_ and heightLayoutPolicy_ to TEST_CONTAINER_SIZE，NO_MATCH. + * @tc.expected: step4. switchSize is equal to TEST_CONTAINER_SIZE. + */ + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(switchSize, TEST_CONTAINER_SIZE); + /** + * @tc.steps: step4. set widthLayoutPolicy_ and heightLayoutPolicy_ to FIX_AT_IDEAL_SIZE,NO_MATCH. + * @tc.expected: step4. switchSize is equal to TEST_CONTAINER_SIZE. + */ + contentConstraint.selfIdealSize.SetSize(TEST_CONTAINER_SIZE); + switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(switchSize, TEST_CONTAINER_SIZE); + MockContainer::Current()->SetApiTargetVersion(rollbackApiVersion); +} + +/** + * @tc.name: ToggleFixIdealSizeTest002 + * @tc.desc: Test toggle switch fixIdealSize. + * @tc.type: FUNC + */ +HWTEST_F(ToggleSwitchTestNg, ToggleFixIdealSizeTest002, TestSize.Level1) +{ + int32_t rollbackApiVersion = MockContainer::Current()->GetApiTargetVersion(); + int32_t setApiVersion = static_cast(PlatformVersion::VERSION_TWELVE); + MockContainer::Current()->SetApiTargetVersion(setApiVersion); + + /** + * @tc.steps: step1. create switch and get frameNode. + */ + ToggleModelNG toggleModelNG; + toggleModelNG.Create(ToggleType::SWITCH, IS_ON); + auto switchFrameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + EXPECT_NE(switchFrameNode, nullptr); + + /** + * @tc.steps: step2. get switchPattern and switchWrapper. + * @tc.expected: step2. get switchPattern success. + */ + auto switchPattern = AceType::DynamicCast(switchFrameNode->GetPattern()); + EXPECT_NE(switchPattern, nullptr); + RefPtr geometryNode = AceType::MakeRefPtr(); + EXPECT_NE(switchFrameNode, nullptr); + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(switchFrameNode, geometryNode, switchFrameNode->GetLayoutProperty()); + auto switchLayoutAlgorithm = AceType::DynamicCast(switchPattern->CreateLayoutAlgorithm()); + EXPECT_NE(switchLayoutAlgorithm, nullptr); + layoutWrapper.SetLayoutAlgorithm(AccessibilityManager::MakeRefPtr(switchLayoutAlgorithm)); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to NO_MATCH,FIX_AT_IDEAL_SIZE. + * @tc.expected: step3. switchSize is not equal to TEST_CONTAINER_SIZE. + */ + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_CONTAINER_SIZE); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + auto switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(switchSize, TEST_CONTAINER_SIZE); + + /** + * @tc.steps: step4. set widthLayoutPolicy_ and heightLayoutPolicy_ to FIX_AT_IDEAL_SIZE,NO_MATCH. + * @tc.expected: step4. switchSize is equal to TEST_CONTAINER_SIZE. + */ + contentConstraint.selfIdealSize.SetSize(TEST_CONTAINER_SIZE); + switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(switchSize, TEST_CONTAINER_SIZE); + MockContainer::Current()->SetApiTargetVersion(rollbackApiVersion); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to NO_MATCH. + */ + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + float frameWidth = 0.0f; + float frameHeight = 0.0f; + switchLayoutAlgorithm->LayoutPolicyIsFixAtIdelSize(contentConstraint, layoutPolicyProperty, + frameWidth, frameHeight); + EXPECT_FLOAT_EQ(frameWidth, TEST_ZERO); + EXPECT_FLOAT_EQ(frameHeight, TEST_ZERO); +} + +/** + * @tc.name: ToggleWrapContentTest001 + * @tc.desc: Test toggle switch WrapContent. + * @tc.type: FUNC + */ +HWTEST_F(ToggleSwitchTestNg, ToggleWrapContentTest001, TestSize.Level1) +{ + int32_t rollbackApiVersion = MockContainer::Current()->GetApiTargetVersion(); + int32_t setApiVersion = static_cast(PlatformVersion::VERSION_TWELVE); + MockContainer::Current()->SetApiTargetVersion(setApiVersion); + + /** + * @tc.steps: step1. create switch and get frameNode. + */ + ToggleModelNG toggleModelNG; + toggleModelNG.Create(ToggleType::SWITCH, IS_ON); + auto switchFrameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + EXPECT_NE(switchFrameNode, nullptr); + + /** + * @tc.steps: step2. get switchPattern and switchWrapper. + * @tc.expected: step2. get switchPattern success. + */ + auto switchPattern = AceType::DynamicCast(switchFrameNode->GetPattern()); + EXPECT_NE(switchPattern, nullptr); + RefPtr geometryNode = AceType::MakeRefPtr(); + EXPECT_NE(switchFrameNode, nullptr); + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(switchFrameNode, geometryNode, switchFrameNode->GetLayoutProperty()); + auto switchLayoutAlgorithm = AceType::DynamicCast(switchPattern->CreateLayoutAlgorithm()); + EXPECT_NE(switchLayoutAlgorithm, nullptr); + layoutWrapper.SetLayoutAlgorithm(AccessibilityManager::MakeRefPtr(switchLayoutAlgorithm)); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to null. + * @tc.expected: step3. switchSize is not equal to TEST_CONTAINER_SIZE. + */ + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_CONTAINER_SIZE); + auto switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(switchSize, TEST_CONTAINER_SIZE); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to WRAP_CONTENT,WRAP_CONTENT. + * @tc.expected: step3. switchSize is not equal to TEST_CONTAINER_SIZE. + */ + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(switchSize, TEST_CONTAINER_SIZE); + + /** + * @tc.steps: step4. set widthLayoutPolicy_ and heightLayoutPolicy_ to TEST_CONTAINER_SIZE，NO_MATCH. + * @tc.expected: step4. switchSize is equal to TEST_CONTAINER_SIZE. + */ + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(switchSize, TEST_CONTAINER_SIZE); + /** + * @tc.steps: step4. set widthLayoutPolicy_ and heightLayoutPolicy_ to WRAP_CONTENT,NO_MATCH. + * @tc.expected: step4. switchSize is equal to TEST_CONTAINER_SIZE. + */ + contentConstraint.selfIdealSize.SetSize(TEST_CONTAINER_SIZE); + switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(switchSize, TEST_CONTAINER_SIZE); + MockContainer::Current()->SetApiTargetVersion(rollbackApiVersion); +} + +/** + * @tc.name: ToggleWrapContentTest002 + * @tc.desc: Test toggle switch fixIdealSize. + * @tc.type: FUNC + */ +HWTEST_F(ToggleSwitchTestNg, ToggleWrapContentTest002, TestSize.Level1) +{ + int32_t rollbackApiVersion = MockContainer::Current()->GetApiTargetVersion(); + int32_t setApiVersion = static_cast(PlatformVersion::VERSION_TWELVE); + MockContainer::Current()->SetApiTargetVersion(setApiVersion); + + /** + * @tc.steps: step1. create switch and get frameNode. + */ + ToggleModelNG toggleModelNG; + toggleModelNG.Create(ToggleType::SWITCH, IS_ON); + auto switchFrameNode = AceType::DynamicCast(ViewStackProcessor::GetInstance()->Finish()); + EXPECT_NE(switchFrameNode, nullptr); + + /** + * @tc.steps: step2. get switchPattern and switchWrapper. + * @tc.expected: step2. get switchPattern success. + */ + auto switchPattern = AceType::DynamicCast(switchFrameNode->GetPattern()); + EXPECT_NE(switchPattern, nullptr); + RefPtr geometryNode = AceType::MakeRefPtr(); + EXPECT_NE(switchFrameNode, nullptr); + LayoutWrapperNode layoutWrapper = + LayoutWrapperNode(switchFrameNode, geometryNode, switchFrameNode->GetLayoutProperty()); + auto switchLayoutAlgorithm = AceType::DynamicCast(switchPattern->CreateLayoutAlgorithm()); + EXPECT_NE(switchLayoutAlgorithm, nullptr); + layoutWrapper.SetLayoutAlgorithm(AccessibilityManager::MakeRefPtr(switchLayoutAlgorithm)); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to NO_MATCH,WRAP_CONTENT. + * @tc.expected: step3. switchSize is not equal to TEST_CONTAINER_SIZE. + */ + auto layoutProperty = layoutWrapper.GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + LayoutConstraintF contentConstraint; + contentConstraint.parentIdealSize.SetSize(TEST_CONTAINER_SIZE); + LayoutPolicyProperty layoutPolicyProperty; + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::WRAP_CONTENT; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + auto switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_NE(switchSize, TEST_CONTAINER_SIZE); + + /** + * @tc.steps: step4. set widthLayoutPolicy_ and heightLayoutPolicy_ to WRAP_CONTENT,NO_MATCH. + * @tc.expected: step4. switchSize is equal to TEST_CONTAINER_SIZE. + */ + contentConstraint.selfIdealSize.SetSize(TEST_CONTAINER_SIZE); + switchSize = switchLayoutAlgorithm->MeasureContent(contentConstraint, &layoutWrapper); + EXPECT_EQ(switchSize, TEST_CONTAINER_SIZE); + MockContainer::Current()->SetApiTargetVersion(rollbackApiVersion); + + /** + * @tc.steps: step3. set widthLayoutPolicy_ and heightLayoutPolicy_ to NO_MATCH. + */ + layoutPolicyProperty.widthLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutPolicyProperty.heightLayoutPolicy_ = LayoutCalPolicy::NO_MATCH; + layoutProperty->layoutPolicy_ = layoutPolicyProperty; + float frameWidth = 0.0f; + float frameHeight = 0.0f; + switchLayoutAlgorithm->LayoutPolicyIsWrapContent(contentConstraint, layoutPolicyProperty, + frameWidth, frameHeight); + EXPECT_FLOAT_EQ(frameWidth, TEST_ZERO); + EXPECT_FLOAT_EQ(frameHeight, TEST_ZERO); +} + /** * @tc.name: ToggleSwitchLayoutTest015 * @tc.desc: Test LayoutPolicyIsMatchParent.