From 942bfae924fa24d74982de4e20b479cc7560a1d3 Mon Sep 17 00:00:00 2001 From: liuyongkai2 Date: Thu, 17 Jul 2025 20:08:22 +0800 Subject: [PATCH 1/2] =?UTF-8?q?test:=E8=A1=A5=E5=85=85TDD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liuyongkai2 --- test/unittest/core/pattern/overlay/BUILD.gn | 1 + .../sheet_presentation_test_four_ng.cpp | 1844 +++++++++++++++++ .../overlay/sheet_showInSubwindow_test_ng.cpp | 114 + 3 files changed, 1959 insertions(+) create mode 100644 test/unittest/core/pattern/overlay/sheet_presentation_test_four_ng.cpp diff --git a/test/unittest/core/pattern/overlay/BUILD.gn b/test/unittest/core/pattern/overlay/BUILD.gn index 1c908aa483f..b84d0f3854a 100644 --- a/test/unittest/core/pattern/overlay/BUILD.gn +++ b/test/unittest/core/pattern/overlay/BUILD.gn @@ -40,6 +40,7 @@ ace_unittest("overlay_manager_test_ng") { "sheet_drag_bar_test_ng.cpp", "sheet_others_test_ng.cpp", "sheet_popup_test_ng.cpp", + "sheet_presentation_test_four_ng.cpp", "sheet_presentation_test_ng.cpp", "sheet_presentation_test_three_ng.cpp", "sheet_presentation_test_two_ng.cpp", diff --git a/test/unittest/core/pattern/overlay/sheet_presentation_test_four_ng.cpp b/test/unittest/core/pattern/overlay/sheet_presentation_test_four_ng.cpp new file mode 100644 index 00000000000..77386b54e42 --- /dev/null +++ b/test/unittest/core/pattern/overlay/sheet_presentation_test_four_ng.cpp @@ -0,0 +1,1844 @@ +/* + * Copyright (c) 2024 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 +#include +#include + +#include "gtest/gtest.h" + +#define private public +#define protected public + +#include "test/mock/base/mock_foldable_window.h" +#include "test/mock/core/common/mock_container.h" +#include "test/mock/core/common/mock_theme_manager.h" +#include "test/mock/core/common/mock_window.h" +#include "test/mock/core/pipeline/mock_pipeline_context.h" + +#include "core/components_ng/pattern/overlay/sheet_drag_bar_pattern.h" +#include "core/components_ng/pattern/overlay/sheet_presentation_pattern.h" +#include "core/components_ng/pattern/overlay/sheet_style.h" +#include "core/components_ng/pattern/overlay/sheet_view.h" +#include "core/components_ng/pattern/overlay/sheet_wrapper_pattern.h" +#include "core/components_ng/pattern/root/root_pattern.h" +#include "core/components_ng/pattern/scroll/scroll_pattern.h" +#include "core/components_ng/pattern/stage/page_pattern.h" +#include "core/components_ng/pattern/text/text_layout_property.h" + +using namespace testing; +using namespace testing::ext; +namespace OHOS::Ace::NG { +namespace { +const int32_t fingerId = 1; +} // namespace + +class SheetPresentationTestFourNg : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); +}; + +void SheetPresentationTestFourNg::SetUpTestCase() +{ + MockPipelineContext::SetUp(); + MockContainer::SetUp(); + auto themeManager = AceType::MakeRefPtr(); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly([](ThemeType type) -> RefPtr { + if (type == SheetTheme::TypeId()) { + auto sheetTheme = AceType::MakeRefPtr(); + sheetTheme->closeIconButtonWidth_ = SHEET_CLOSE_ICON_WIDTH; + sheetTheme->centerDefaultWidth_ = SHEET_LANDSCAPE_WIDTH; + sheetTheme->sheetCloseIconTitleSpaceNew_ = SHEET_CLOSE_ICON_TITLE_SPACE_NEW; + return sheetTheme; + } else { + return nullptr; + } + }); + MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); +} + +void SheetPresentationTestFourNg::TearDownTestCase() +{ + MockPipelineContext::TearDown(); + MockContainer::TearDown(); +} + +/** + * @tc.name: UpdateAccessibilityDetents001 + * @tc.desc: UpdateAccessibilityDetents true + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, UpdateAccessibilityDetents001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + auto count = sheetPattern->sheetDetentHeight_.size(); + EXPECT_EQ(count, 5); + sheetPattern->sheetType_ = SheetType::SHEET_BOTTOM; + auto res = sheetPattern->UpdateAccessibilityDetents(10.0f); + EXPECT_TRUE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: OnCoordScrollUpdate001 + * @tc.desc: OnCoordScrollUpdate false + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, OnCoordScrollUpdate001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto count = sheetPattern->sheetDetentHeight_.size(); + EXPECT_EQ(count, 0); + auto scrollNode = sheetPattern->GetSheetScrollNode(); + CHECK_NULL_VOID(scrollNode); + auto scrollPattern = scrollNode->GetPattern(); + CHECK_NULL_VOID(scrollPattern); + scrollPattern->scrollableDistance_ = 10.0f; + auto res = sheetPattern->OnCoordScrollUpdate(10.0f); + EXPECT_FALSE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: OnCoordScrollUpdate002 + * @tc.desc: OnCoordScrollUpdate false + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, OnCoordScrollUpdate002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(0.0f); + auto count = sheetPattern->sheetDetentHeight_.size(); + EXPECT_EQ(count, 5); + sheetPattern->currentOffset_ = 0.0f; + auto scrollNode = sheetPattern->GetSheetScrollNode(); + CHECK_NULL_VOID(scrollNode); + auto scrollPattern = scrollNode->GetPattern(); + CHECK_NULL_VOID(scrollPattern); + scrollPattern->scrollableDistance_ = 10.0f; + auto res = sheetPattern->OnCoordScrollUpdate(0.0f); + EXPECT_FALSE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: OnCoordScrollUpdate003 + * @tc.desc: OnCoordScrollUpdate false + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, OnCoordScrollUpdate003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + EXPECT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + EXPECT_NE(sheetPattern, nullptr); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + auto count = sheetPattern->sheetDetentHeight_.size(); + EXPECT_EQ(count, 5); + sheetPattern->pageHeight_ = 10.0f; + sheetPattern->height_ = 10.0f; + auto scrollNode = sheetPattern->GetSheetScrollNode(); + CHECK_NULL_VOID(scrollNode); + auto scrollPattern = scrollNode->GetPattern(); + CHECK_NULL_VOID(scrollPattern); + scrollPattern->scrollableDistance_ = 10.0f; + auto res = sheetPattern->OnCoordScrollUpdate(10.0f); + EXPECT_TRUE(sheetPattern->GetShowState()); + EXPECT_TRUE(sheetPattern->IsScrollable()); + EXPECT_TRUE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragEndAccessibilityEvent001 + * @tc.desc: HandleDragEndAccessibilityEvent event.beforeText + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndAccessibilityEvent001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + auto count = sheetPattern->sheetDetentHeight_.size(); + EXPECT_EQ(count, 5); + sheetPattern->height_ = 10.0f; + sheetPattern->sheetType_ = SheetType::SHEET_BOTTOM; + auto res = sheetPattern->UpdateAccessibilityDetents(sheetPattern->GetSheetHeightBeforeDragUpdate()); + EXPECT_TRUE(res); + AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); + sheetPattern->HandleDragEndAccessibilityEvent(); + AccessibilityEvent event; + EXPECT_EQ(event.beforeText, ""); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetWindowButtonRect001 + * @tc.desc: GetWindowButtonRect EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetWindowButtonRect001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + AceApplicationInfo::GetInstance().apiVersion_ = 1019; + auto pipeline = PipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + auto avoidInfoMgr = pipeline->GetAvoidInfoManager(); + ASSERT_NE(avoidInfoMgr, nullptr); + avoidInfoMgr->instanceId_ = 1001; + avoidInfoMgr->avoidInfo_.needAvoid = true; + NG::RectF floatButtons; + floatButtons.SetHeight(10.0f); + floatButtons.SetWidth(10.0f); + auto res = sheetPattern->GetWindowButtonRect(floatButtons); + EXPECT_TRUE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: InitialSingleGearHeight001 + * @tc.desc: InitialSingleGearHeight sheetHeight + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, InitialSingleGearHeight001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + NG::SheetStyle sheetStyle; + sheetStyle.sheetHeight.sheetMode = SheetMode::MEDIUM; + Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_EIGHTEEN); + sheetPattern->pageHeight_ = 10.0f; + auto sheetHeight = sheetPattern->InitialSingleGearHeight(sheetStyle); + EXPECT_EQ(sheetHeight, 5.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: UpdateSheetTransitionOffset001 + * @tc.desc: UpdateSheetTransitionOffset sheetHeightUp_ + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, UpdateSheetTransitionOffset001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->isSpringBack_ = true; + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + sheetPattern->sheetDetentHeight_.push_back(10.0f); + auto count = sheetPattern->sheetDetentHeight_.size(); + EXPECT_EQ(count, 5); + sheetPattern->UpdateSheetTransitionOffset(); + EXPECT_EQ(sheetPattern->sheetHeightUp_, 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: SheetHeightNeedChanged001 + * @tc.desc: SheetHeightNeedChanged EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, SheetHeightNeedChanged001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto sheetGeometryNode = sheetNode->GetGeometryNode(); + CHECK_NULL_VOID(sheetGeometryNode); + + auto size = sheetGeometryNode->GetFrameSize(); + size.SetHeight(100.0f); + sheetGeometryNode->SetFrameSize(size); + + CHECK_NULL_VOID(sheetPattern->sheetObject_); + sheetPattern->sheetObject_->SetSheetHeight(50.0f); + + auto res = sheetPattern->SheetHeightNeedChanged(); + EXPECT_TRUE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckSheetHeightChange001 + * @tc.desc: isRenderDirtyMarked_ EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckSheetHeightChange001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->typeChanged_ = true; + sheetPattern->isFirstInit_ = false; + sheetPattern->sheetType_ = SheetType::SHEET_POPUP; + sheetNode->isRenderDirtyMarked_ = false; + sheetNode->isLayoutDirtyMarked_ = false; + auto sheetGeometryNode = sheetNode->GetGeometryNode(); + sheetGeometryNode->SetFrameSize(SizeF(100.0f, 200.0f)); + CHECK_NULL_VOID(sheetPattern->sheetObject_); + sheetPattern->CheckSheetHeightChange(); + EXPECT_TRUE(sheetNode->isRenderDirtyMarked_); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckSheetHeightChange002 + * @tc.desc: CheckSheetHeightChange PROPERTY_UPDATE_LAYOUT | PROPERTY_UPDATE_MEASURE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckSheetHeightChange002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->typeChanged_ = true; + sheetPattern->sheetType_ = SheetType::SHEET_BOTTOM; + auto layoutProperty = sheetPattern->GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + auto sheetGeometryNode = sheetNode->GetGeometryNode(); + sheetGeometryNode->SetFrameSize(SizeF(100.0f, 200.0f)); + CHECK_NULL_VOID(sheetPattern->sheetObject_); + sheetPattern->CheckSheetHeightChange(); + EXPECT_EQ(layoutProperty->propertyChangeFlag_, PROPERTY_UPDATE_LAYOUT | PROPERTY_UPDATE_MEASURE); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: IsCustomDetentsChanged001 + * @tc.desc: IsCustomDetentsChanged + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, IsCustomDetentsChanged001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->detentsFinalIndex_ = 1; + SheetHeight detent; + detent.sheetMode = SheetMode::MEDIUM; + SheetStyle sheetStyle; + + SheetHeight preDetents; + preDetents.sheetMode = SheetMode::LARGE; + sheetStyle.detents.emplace_back(detent); + sheetPattern->preDetents_.emplace_back(preDetents); + unsigned int preDetentsSize = sheetPattern->preDetents_.size(); + unsigned int userSetDetentsSize = sheetStyle.detents.size(); + EXPECT_EQ(preDetentsSize, 1); + EXPECT_EQ(userSetDetentsSize, 1); + sheetPattern->IsCustomDetentsChanged(sheetStyle); + EXPECT_EQ(sheetPattern->detentsFinalIndex_, 0); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: IsCustomDetentsChanged002 + * @tc.desc: IsCustomDetentsChanged + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, IsCustomDetentsChanged002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + sheetPattern->detentsFinalIndex_ = 1; + ASSERT_NE(sheetPattern, nullptr); + SheetHeight detent; + detent.sheetMode = SheetMode::MEDIUM; + SheetStyle sheetStyle; + + SheetHeight preDetents; + preDetents.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + sheetPattern->preDetents_.emplace_back(preDetents); + unsigned int preDetentsSize = sheetPattern->preDetents_.size(); + unsigned int userSetDetentsSize = sheetStyle.detents.size(); + EXPECT_EQ(preDetentsSize, 1); + EXPECT_EQ(userSetDetentsSize, 1); + sheetPattern->IsCustomDetentsChanged(sheetStyle); + EXPECT_EQ(sheetPattern->detentsFinalIndex_, 1); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetSubWindowId001 + * @tc.desc: GetSubWindowId INVALID_SUBWINDOW_ID + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetSubWindowId001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr( + ElementRegister::GetInstance()->MakeUniqueId(), V2::TEXT_ETS_TAG, std::move(callback))); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto sheetWrapperNode = FrameNode::CreateFrameNode(V2::SHEET_WRAPPER_TAG, + ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr()); + auto sheetWrapperPattern = sheetWrapperNode->GetPattern(); + ASSERT_NE(sheetWrapperPattern, nullptr); + EXPECT_EQ(sheetWrapperPattern->GetSubWindowId(), INVALID_SUBWINDOW_ID); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: OnWindowSizeChangedTest001 + * @tc.desc: OnWindowSizeChanged EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, OnWindowSizeChangedTest001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr( + ElementRegister::GetInstance()->MakeUniqueId(), V2::TEXT_ETS_TAG, std::move(callback))); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->windowSize_ = SizeT(1600, 800); + sheetPattern->OnWindowSizeChanged(100, 100, WindowSizeChangeReason::UNDEFINED); + EXPECT_TRUE(sheetPattern->windowChanged_); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: AdditionalScrollTo001 + * @tc.desc: AdditionalScrollTo EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, AdditionalScrollTo001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr( + ElementRegister::GetInstance()->MakeUniqueId(), V2::TEXT_ETS_TAG, std::move(callback))); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto scrollNode = FrameNode::CreateFrameNode("Scroll", 501, AceType::MakeRefPtr()); + ASSERT_NE(scrollNode, nullptr); + + auto scrollGeometryNode = scrollNode->GetGeometryNode(); + ASSERT_NE(scrollGeometryNode, nullptr); + auto size = scrollGeometryNode->GetFrameSize(); + size.SetHeight(100.0f); + scrollGeometryNode->SetFrameSize(size); + + auto buildContent = sheetPattern->GetFirstFrameNodeOfBuilder(); + CHECK_NULL_VOID(buildContent); + auto buildContentGeometryNode = buildContent->GetGeometryNode(); + ASSERT_NE(buildContentGeometryNode, nullptr); + auto size1 = buildContentGeometryNode->GetFrameSize(); + size1.SetHeight(50.0f); + buildContentGeometryNode->SetFrameSize(size1); + auto res = sheetPattern->AdditionalScrollTo(scrollNode, 10.0f); + EXPECT_TRUE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetOverlayManagertest001 + * @tc.desc: GetOverlayManager OverlayManager + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetOverlayManagertest001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr( + ElementRegister::GetInstance()->MakeUniqueId(), V2::TEXT_ETS_TAG, std::move(callback))); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto layoutProperty = sheetPattern->GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + + SheetStyle currentStyle = layoutProperty->GetSheetStyleValue(SheetStyle()); + currentStyle.showInSubWindow = false; + auto OverlayManager = sheetPattern->GetOverlayManager(); + ASSERT_NE(OverlayManager, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetCurrentScrollHeight001 + * @tc.desc: GetCurrentScrollHeight scrollHeight_ + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetCurrentScrollHeight001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr( + ElementRegister::GetInstance()->MakeUniqueId(), V2::TEXT_ETS_TAG, std::move(callback))); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto scrollNode = sheetPattern->GetSheetScrollNode(); + CHECK_NULL_VOID(scrollNode); + auto scrollPattern = scrollNode->GetPattern(); + CHECK_NULL_VOID(scrollPattern); + scrollPattern->currentOffset_ = -100.0f; + sheetPattern->scrollHeight_ = 200.0f; + + sheetPattern->GetCurrentScrollHeight(); + EXPECT_EQ(sheetPattern->scrollHeight_, 100.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: UpdateSheetWhenSheetTypeChanged001 + * @tc.desc: UpdateSheetWhenSheetTypeChanged + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, UpdateSheetWhenSheetTypeChanged001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr( + ElementRegister::GetInstance()->MakeUniqueId(), V2::TEXT_ETS_TAG, std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + sheetPattern->sheetType_ = SheetType::SHEET_POPUP; + sheetNode->isRenderDirtyMarked_ = false; + sheetNode->isLayoutDirtyMarked_ = false; + + CHECK_NULL_VOID(sheetPattern->sheetObject_); + sheetPattern->UpdateSheetWhenSheetTypeChanged(); + EXPECT_TRUE(sheetNode->isRenderDirtyMarked_); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragStart001 + * @tc.desc: HandleDragStart + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragStart001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetNode, nullptr); + auto sheetObject = sheetPattern->GetSheetObject(); + CHECK_NULL_VOID(sheetObject); + + sheetPattern->isAnimationProcess_ = false; + sheetObject->HandleDragStart(); + EXPECT_TRUE(sheetPattern->IsDragging()); + EXPECT_FLOAT_EQ(sheetPattern->currentOffset_, 0.0f); + EXPECT_TRUE(sheetPattern->GetIsDirectionUp()); + EXPECT_FALSE(sheetPattern->GetAnimationBreak()); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragStart002 + * @tc.desc: HandleDragStart + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragStart002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetNode, nullptr); + auto sheetObject = sheetPattern->GetSheetObject(); + CHECK_NULL_VOID(sheetObject); + + AnimationOption option; + auto propertyCallback = []() {}; + sheetPattern->animation_ = AnimationUtils::StartAnimation(option, propertyCallback); + sheetPattern->isAnimationProcess_ = true; + sheetObject->HandleDragStart(); + EXPECT_TRUE(sheetPattern->IsDragging()); + EXPECT_FLOAT_EQ(sheetPattern->currentOffset_, 0.0f); + EXPECT_TRUE(sheetPattern->GetIsDirectionUp()); + EXPECT_TRUE(sheetPattern->GetAnimationBreak()); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionBottom001 + * @tc.desc: CheckDirectionBottom EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionBottom001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 1200); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionBottom(targetSize, targetOffset); + EXPECT_TRUE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionBottom002 + * @tc.desc: CheckDirectionBottom EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionBottom002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 800); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionBottom(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionBottom003 + * @tc.desc: CheckDirectionBottom EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionBottom003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 800); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 500.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionBottom(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionTop001 + * @tc.desc: CheckDirectionTop EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionTop001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 1200); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 50.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionTop(targetSize, targetOffset); + EXPECT_TRUE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionTop002 + * @tc.desc: CheckDirectionTop EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionTop002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 800); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 500.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionTop(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionTop003 + * @tc.desc: CheckDirectionTop EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionTop003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 1200); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionTop(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionRight001 + * @tc.desc: CheckDirectionRight EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionRight001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 800); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionRight(targetSize, targetOffset); + EXPECT_TRUE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionRight002 + * @tc.desc: CheckDirectionRight EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionRight002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 800); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 500.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 300.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionRight(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionRight003 + * @tc.desc: CheckDirectionRight EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionRight003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 500.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionRight(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionRight001 + * @tc.desc: CheckDirectionLeft EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionLeft001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(150.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 800); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 500.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionLeft(targetSize, targetOffset); + EXPECT_TRUE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionRight001 + * @tc.desc: CheckDirectionLeft EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionLeft002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 500.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionLeft(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckDirectionRight001 + * @tc.desc: CheckDirectionLeft EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckDirectionLeft003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(150.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 500.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckDirectionLeft(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckPlacementBottom001 + * @tc.desc: CheckPlacementBottom EXPECT TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckPlacementBottom001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(150.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 450.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckPlacementBottom(targetSize, targetOffset); + EXPECT_TRUE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckPlacementBottom002 + * @tc.desc: CheckPlacementBottom EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckPlacementBottom002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(300.0f, 400.0f); + OffsetF targetOffset(150.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 300, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 450.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckPlacementBottom(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckPlacementBottom003 + * @tc.desc: CheckPlacementBottom EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckPlacementBottom003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(10.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 450.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckPlacementBottom(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckPlacementBottomRight001 + * @tc.desc: CheckPlacementBottomRight EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckPlacementBottomRight001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(60.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 450.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckPlacementBottomRight(targetSize, targetOffset); + EXPECT_TRUE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckPlacementBottomRight001 + * @tc.desc: CheckPlacementBottomRight EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckPlacementBottomRight002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(40.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 500, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 450.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckPlacementBottomRight(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: CheckPlacementBottomRight001 + * @tc.desc: CheckPlacementBottomRight EXPECT FLASE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, CheckPlacementBottomRight003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(60.0f, 400.0f); + OffsetF targetOffset(50.0f, 100.0f); + + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->windowGlobalRect_ = Rect(0, 0, 100, 500); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 100.0f; + sheetWrapperLayoutAlgorithm->sheetHeight_ = 450.0f; + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopLeft = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->sheetRadius_.radiusTopRight = Dimension(10.0f); + sheetWrapperLayoutAlgorithm->windowEdgeWidth_ = 5.0f; + + bool result = sheetWrapperLayoutAlgorithm->CheckPlacementBottomRight(targetSize, targetOffset); + EXPECT_FALSE(result); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: SetArrowOffsetInBottomOrTop001 + * @tc.desc: SetArrowOffsetInBottomOrTop + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, SetArrowOffsetInBottomOrTop001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(200.0f, 100.0f); + OffsetF targetOffset(400.0f, 0.0f); + float sheetOffset = 150.0f; + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 300.0f; + + sheetWrapperLayoutAlgorithm->SetArrowOffsetInBottomOrTop(targetSize, targetOffset, sheetOffset); + EXPECT_FLOAT_EQ(sheetWrapperLayoutAlgorithm->sheetPopupInfo_.arrowOffsetX, 292.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: SetArrowOffsetInRightOrLeft001 + * @tc.desc: SetArrowOffsetInRightOrLeft + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, SetArrowOffsetInRightOrLeft001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SizeF targetSize(200.0f, 100.0f); + OffsetF targetOffset(400.0f, 0.0f); + float sheetOffset = 150.0f; + auto sheetWrapperLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetWrapperLayoutAlgorithm, nullptr); + sheetWrapperLayoutAlgorithm->sheetWidth_ = 300.0f; + + sheetWrapperLayoutAlgorithm->SetArrowOffsetInRightOrLeft(targetSize, targetOffset, sheetOffset); + EXPECT_FLOAT_EQ(sheetWrapperLayoutAlgorithm->sheetPopupInfo_.arrowOffsetY, 8.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: IsSingleDetents001 + * @tc.desc: IsSingleDetents FALSE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, IsSingleDetents001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + NG::SheetStyle sheetStyle; + SheetHeight detent; + detent.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + detent.sheetMode = SheetMode::LARGE; + sheetStyle.detents.emplace_back(detent); + auto res = SheetView::IsSingleDetents(sheetStyle); + EXPECT_FALSE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: IsSingleDetents002 + * @tc.desc: IsSingleDetents TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, IsSingleDetents002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + NG::SheetStyle sheetStyle; + SheetHeight detent; + detent.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + detent.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + auto res = SheetView::IsSingleDetents(sheetStyle); + EXPECT_TRUE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: IsSingleDetents003 + * @tc.desc: IsSingleDetents FALSE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, IsSingleDetents003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + NG::SheetStyle sheetStyle; + SheetHeight detent; + detent.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + detent.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + detent.sheetMode = SheetMode::LARGE; + sheetStyle.detents.emplace_back(detent); + auto res = SheetView::IsSingleDetents(sheetStyle); + EXPECT_FALSE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: IsSingleDetents004 + * @tc.desc: IsSingleDetents TRUE + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, IsSingleDetents004, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + NG::SheetStyle sheetStyle; + SheetHeight detent; + detent.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + detent.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + detent.sheetMode = SheetMode::MEDIUM; + sheetStyle.detents.emplace_back(detent); + auto res = SheetView::IsSingleDetents(sheetStyle); + EXPECT_TRUE(res); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: MinusSubwindowDistance001 + * @tc.desc: MinusSubwindowDistance + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, MinusSubwindowDistance001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto sheetPageLayoutAlgorithm = AceType::MakeRefPtr(); + ASSERT_NE(sheetPageLayoutAlgorithm, nullptr); + auto sheetWrapperNode = FrameNode::CreateFrameNode(V2::SHEET_WRAPPER_TAG, + ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr()); + auto sheetWrapperPattern = sheetWrapperNode->GetPattern(); + ASSERT_NE(sheetWrapperPattern, nullptr); + auto subContainer = AceEngine::Get().GetContainer(sheetWrapperPattern->GetSubWindowId()); + CHECK_NULL_VOID(subContainer); + auto subWindowContext = AceType::DynamicCast(subContainer->GetPipelineContext()); + CHECK_NULL_VOID(subWindowContext); + subWindowContext->displayWindowRectInfo_ = Rect(0, 0, 100.0f, 100.0f); + + sheetPageLayoutAlgorithm->sheetOffsetX_ = 100.0f; + sheetPageLayoutAlgorithm->sheetOffsetY_ = 100.0f; + sheetPageLayoutAlgorithm->MinusSubwindowDistance(sheetWrapperNode); + EXPECT_FLOAT_EQ(sheetPageLayoutAlgorithm->sheetOffsetX_, 100.0f); + EXPECT_FLOAT_EQ(sheetPageLayoutAlgorithm->sheetOffsetY_, 100.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleTouchDown001 + * @tc.desc: HandleTouchDown + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleTouchDown001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + TouchLocationInfo info(fingerId); + info.globalLocation_ = Offset(100.0f, 100.0f); + auto dragBarNode = + FrameNode::CreateFrameNode("SheetDragBarNode", 04, AceType::MakeRefPtr()); + ASSERT_NE(dragBarNode, nullptr); + auto dragBarPattern = dragBarNode->GetPattern(); + ASSERT_NE(dragBarPattern, nullptr); + dragBarPattern->HandleTouchDown(info); + EXPECT_FLOAT_EQ(dragBarPattern->downPoint_.GetX(), 100.0f); + EXPECT_FLOAT_EQ(dragBarPattern->downPoint_.GetY(), 100.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetContentDrawFunction001 + * @tc.desc: GetContentDrawFunction + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetContentDrawFunction001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + SheetDragBarPaintMethod sheetdragbarpaintmethod; + auto paintFunc = sheetdragbarpaintmethod.GetContentDrawFunction(nullptr); + EXPECT_EQ(paintFunc, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetContentDrawFunction001 + * @tc.desc: GetContentDrawFunction + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetContentDrawFunction002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto columnNode = + FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + []() { return AceType::MakeRefPtr(true); }); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr( + ElementRegister::GetInstance()->MakeUniqueId(), V2::TEXT_ETS_TAG, std::move(callback))); + columnNode->AddChild(sheetNode); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto sheetPaintWrapper = new PaintWrapper( + columnNode->GetRenderContext(), sheetNode->GetGeometryNode(), sheetNode->GetPaintProperty()); + SheetDragBarPaintMethod sheetdragbarpaintmethod; + auto paintFunc = sheetdragbarpaintmethod.GetContentDrawFunction(sheetPaintWrapper); + EXPECT_NE(paintFunc, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetAvoidKeyboardModeByDefault001 + * @tc.desc: GetAvoidKeyboardModeByDefault + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetAvoidKeyboardModeByDefault001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + auto sheetPattern = sheetNode->GetPattern(); + sheetPattern->animation_ = nullptr; + EXPECT_EQ(sheetPattern->animation_, nullptr); + sheetPattern->InitSheetObject(); + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + + sheetObject->sheetType_ = SheetType::SHEET_POPUP; + auto sheetKeyboardAvoidMode = sheetObject->GetAvoidKeyboardModeByDefault(); + EXPECT_EQ(sheetKeyboardAvoidMode, SheetKeyboardAvoidMode::NONE); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetAvoidKeyboardModeByDefault001 + * @tc.desc: GetAvoidKeyboardModeByDefault + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetAvoidKeyboardModeByDefault002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode( + "Sheet", 101, AceType::MakeRefPtr(201, "SheetPresentation", std::move(callback))); + auto sheetPattern = sheetNode->GetPattern(); + sheetPattern->animation_ = nullptr; + EXPECT_EQ(sheetPattern->animation_, nullptr); + sheetPattern->InitSheetObject(); + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + + sheetObject->sheetType_ = SheetType::SHEET_CENTER; + auto sheetKeyboardAvoidMode = sheetObject->GetAvoidKeyboardModeByDefault(); + EXPECT_EQ(sheetKeyboardAvoidMode, SheetKeyboardAvoidMode::TRANSLATE_AND_SCROLL); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: DirtyLayoutProcess001 + * @tc.desc: DirtyLayoutProcess + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, DirtyLayoutProcess001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto dirty = sheetNode->CreateLayoutWrapper(); + ASSERT_NE(dirty, nullptr); + auto layoutAlgorithmWrapper = AceType::DynamicCast(dirty->GetLayoutAlgorithm()); + ASSERT_NE(layoutAlgorithmWrapper, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + auto algorithm = AceType::MakeRefPtr(); + algorithm->sheetMaxWidth_ = 1.0f; + algorithm->sheetHeight_ = 100.0f; + object->DirtyLayoutProcess(layoutAlgorithmWrapper); + EXPECT_EQ(sheetPattern->centerHeight_, 100.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: DirtyLayoutProcess002 + * @tc.desc: DirtyLayoutProcess + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, DirtyLayoutProcess002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto dirty = sheetNode->CreateLayoutWrapper(); + ASSERT_NE(dirty, nullptr); + auto layoutAlgorithmWrapper = AceType::DynamicCast(dirty->GetLayoutAlgorithm()); + ASSERT_NE(layoutAlgorithmWrapper, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + auto algorithm = AceType::MakeRefPtr(); + algorithm->sheetMaxWidth_ = 0.0f; + algorithm->sheetHeight_ = 50.0f; + sheetPattern->centerHeight_ = 100.0f; + object->DirtyLayoutProcess(layoutAlgorithmWrapper); + EXPECT_EQ(sheetPattern->centerHeight_, 100.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: UpdateSidePosition001 + * @tc.desc: UpdateSidePosition + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, UpdateSidePosition001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto context = sheetNode->GetRenderContext(); + CHECK_NULL_VOID(context); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + sheetPattern->isOnAppearing_ = false; + sheetPattern->isOnDisappearing_ = false; + sheetPattern->isDrag_ = false; + + AceApplicationInfo::GetInstance().isRightToLeft_ = false; + object->sheetMaxWidth_ = 100.0f; + object->sheetWidth_ = 50.0f; + object->UpdateSidePosition(); + const auto& transform = context->GetTransform(); + auto translation = transform->GetTransformTranslate(); + EXPECT_EQ(translation->x.Value(), 50.0f); + EXPECT_EQ(translation->y.Value(), 0.0f); + EXPECT_EQ(translation->z.Value(), 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: UpdateSidePosition002 + * @tc.desc: UpdateSidePosition + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, UpdateSidePosition002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto context = sheetNode->GetRenderContext(); + CHECK_NULL_VOID(context); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + sheetPattern->isOnAppearing_ = false; + sheetPattern->isOnDisappearing_ = false; + sheetPattern->isDrag_ = false; + + AceApplicationInfo::GetInstance().isRightToLeft_ = true; + object->sheetMaxWidth_ = 100.0f; + object->sheetWidth_ = 50.0f; + object->UpdateSidePosition(); + const auto& transform = context->GetTransform(); + auto translation = transform->GetTransformTranslate(); + EXPECT_EQ(translation->x.Value(), 0.0f); + EXPECT_EQ(translation->y.Value(), 0.0f); + EXPECT_EQ(translation->z.Value(), 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetSheetTransitionCurve001 + * @tc.desc: GetSheetTransitionCurve + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetSheetTransitionCurve001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + float dragVelocity = 100.0f; + auto curve = object->GetSheetTransitionCurve(dragVelocity); + + EXPECT_FLOAT_EQ(curve->GetMass(), CURVE_MASS); + EXPECT_FLOAT_EQ(curve->GetStiffness(), CURVE_STIFFNESS); + EXPECT_FLOAT_EQ(curve->GetDamping(), CURVE_DAMPING); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetSheetTransitionFinishEvent001 + * @tc.desc: GetSheetTransitionFinishEvent + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetSheetTransitionFinishEvent001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + bool isTransitionIn = false; + auto event = object->GetSheetTransitionFinishEvent(isTransitionIn); + EXPECT_NE(event, nullptr); + EXPECT_FALSE(sheetPattern->isAnimationProcess_); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetSheetTransitionFinishEvent002 + * @tc.desc: GetSheetTransitionFinishEvent + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetSheetTransitionFinishEvent002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + bool isTransitionIn = true; + sheetPattern->isAnimationBreak_ = false; + auto event = object->GetSheetTransitionFinishEvent(isTransitionIn); + EXPECT_NE(event, nullptr); + EXPECT_FALSE(sheetPattern->isAnimationProcess_); + EXPECT_EQ(sheetPattern->GetSheetObject()->currentOffset_, 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetSheetTransitionFinishEvent003 + * @tc.desc: GetSheetTransitionFinishEvent + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetSheetTransitionFinishEvent003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + bool isTransitionIn = true; + sheetPattern->isAnimationBreak_ = true; + auto event = object->GetSheetTransitionFinishEvent(isTransitionIn); + EXPECT_NE(event, nullptr); + EXPECT_FALSE(sheetPattern->isAnimationBreak_); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetSheetAnimationEvent001 + * @tc.desc: GetSheetAnimationEvent + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetSheetAnimationEvent001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto context = sheetNode->GetRenderContext(); + CHECK_NULL_VOID(context); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + bool isTransitionIn = true; + float offset = 100.0f; + object->sheetMaxWidth_ = 100.0f; + object->sheetWidth_ = 50.0f; + const auto& transform = context->GetTransform(); + auto translation = transform->GetTransformTranslate(); + AceApplicationInfo::GetInstance().isRightToLeft_ = false; + auto event = object->GetSheetAnimationEvent(isTransitionIn, offset); + EXPECT_NE(event, nullptr); + EXPECT_EQ(translation->x.Value(), 50.0f); + EXPECT_EQ(translation->y.Value(), 0.0f); + EXPECT_EQ(translation->z.Value(), 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetSheetAnimationEvent002 + * @tc.desc: GetSheetAnimationEvent + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetSheetAnimationEvent002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto context = sheetNode->GetRenderContext(); + CHECK_NULL_VOID(context); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + bool isTransitionIn = false; + float offset = 100.0f; + object->sheetMaxWidth_ = 100.0f; + const auto& transform = context->GetTransform(); + auto translation = transform->GetTransformTranslate(); + AceApplicationInfo::GetInstance().isRightToLeft_ = false; + auto event = object->GetSheetAnimationEvent(isTransitionIn, offset); + EXPECT_NE(event, nullptr); + EXPECT_EQ(translation->x.Value(), 100.0f); + EXPECT_EQ(translation->y.Value(), 0.0f); + EXPECT_EQ(translation->z.Value(), 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: SetFinishEventForAnimationOption001 + * @tc.desc: SetFinishEventForAnimationOption + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, SetFinishEventForAnimationOption001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + AnimationOption option; + bool isTransitionIn = true; + bool isFirstTransition = true; + object->SetFinishEventForAnimationOption(option, isTransitionIn, isFirstTransition); + EXPECT_NE(option.onFinishEvent_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragUpdateForLTR001 + * @tc.desc: HandleDragUpdateForLTR + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragUpdateForLTR001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + GestureEvent event; + event.mainDelta_ = 10.0; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = -20.0f; + sheetObject->sheetWidth_ = 10.0f; + object->HandleDragUpdateForLTR(event); + + EXPECT_EQ(sheetPattern->onWidthDidChange_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragUpdateForLTR002 + * @tc.desc: HandleDragUpdateForLTR + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragUpdateForLTR002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + GestureEvent event; + event.mainDelta_ = 10.0; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 10.0f; + sheetObject->sheetWidth_ = 10.0f; + object->HandleDragUpdateForLTR(event); + + EXPECT_NE(sheetPattern->onWidthDidChange_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragUpdateForRTL001 + * @tc.desc: HandleDragUpdateForRTL + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragUpdateForRTL001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + GestureEvent event; + event.mainDelta_ = 10.0; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 10.0f; + sheetObject->sheetWidth_ = 10.0f; + object->HandleDragUpdateForRTL(event); + + EXPECT_EQ(sheetPattern->onWidthDidChange_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragUpdateForRTL002 + * @tc.desc: HandleDragUpdateForRTL + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragUpdateForRTL002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + GestureEvent event; + event.mainDelta_ = 10.0; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = -20.0f; + sheetObject->sheetWidth_ = 10.0f; + object->HandleDragUpdateForRTL(event); + + EXPECT_NE(sheetPattern->onWidthDidChange_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragEndForLTR001 + * @tc.desc: HandleDragEndForLTR + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForLTR001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + float dragVelocity = 500.0f; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 10.0f; + sheetObject->sheetWidth_ = 10.0f; + object->HandleDragEndForLTR(dragVelocity); + EXPECT_TRUE(sheetPattern->isDirectionUp_); + EXPECT_NE(sheetPattern->onWidthDidChange_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} +} // namespace OHOS::Ace::NG \ No newline at end of file diff --git a/test/unittest/core/pattern/overlay/sheet_showInSubwindow_test_ng.cpp b/test/unittest/core/pattern/overlay/sheet_showInSubwindow_test_ng.cpp index 2eee3c3613e..592295d1190 100644 --- a/test/unittest/core/pattern/overlay/sheet_showInSubwindow_test_ng.cpp +++ b/test/unittest/core/pattern/overlay/sheet_showInSubwindow_test_ng.cpp @@ -1714,4 +1714,118 @@ HWTEST_F(SheetShowInSubwindowTestNg, UpdateDragBarStatus001, TestSize.Level1) object->UpdateDragBarStatus(); EXPECT_EQ(dragBarLayoutProperty->propVisibility_, VisibleType::INVISIBLE); } + +/** + * @tc.name: ComputeWidthAndHeight001 + * @tc.desc: ComputeWidthAndHeight sheetHeight, sheetWidth + * @tc.type: FUNC + */ +HWTEST_F(SheetShowInSubwindowTestNg, ComputeWidthAndHeight001, TestSize.Level1) +{ + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto* layoutWrapper = + new LayoutWrapperNode(sheetNode, sheetNode->GetGeometryNode(), sheetNode->GetLayoutProperty()); + ASSERT_NE(layoutWrapper, nullptr); + auto sheetPageLayoutAlgorithm = AceType::MakeRefPtr(); + sheetPageLayoutAlgorithm->sheetStyle_.showInSubWindow = true; + + auto host = layoutWrapper->GetHostNode(); + CHECK_NULL_VOID(host); + auto sheetWrapper = AceType::DynamicCast(host->GetParent()); + CHECK_NULL_VOID(sheetWrapper); + auto sheetWrapperPattern = sheetWrapper->GetPattern(); + CHECK_NULL_VOID(sheetWrapperPattern); + auto mainWindowRect = sheetWrapperPattern->GetMainWindowRect(); + mainWindowRect.SetHeight(100.0f); + mainWindowRect.SetWidth(100.0f); + sheetPageLayoutAlgorithm->ComputeWidthAndHeight(layoutWrapper); + EXPECT_FLOAT_EQ(sheetPageLayoutAlgorithm->sheetHeight_, 100.0f); + EXPECT_FLOAT_EQ(sheetPageLayoutAlgorithm->sheetWidth_, 100.0f); +} + +/** + * @tc.name: ComputeMaxHeight001 + * @tc.desc: ComputeMaxHeight + * @tc.type: FUNC + */ +HWTEST_F(SheetShowInSubwindowTestNg, ComputeMaxHeight001, TestSize.Level1) +{ + float parentConstraintHeight = 100.0f; + float parentConstraintWidth = 100.0f; + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto* layoutWrapper = + new LayoutWrapperNode(sheetNode, sheetNode->GetGeometryNode(), sheetNode->GetLayoutProperty()); + ASSERT_NE(layoutWrapper, nullptr); + NG::RectF floatButtons; + floatButtons.SetHeight(10.0f); + auto pipeline = PipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + auto avoidInfoMgr = pipeline->GetAvoidInfoManager(); + ASSERT_NE(avoidInfoMgr, nullptr); + avoidInfoMgr->instanceId_ = 1001; + avoidInfoMgr->avoidInfo_.needAvoid = true; + + auto sheetPageLayoutAlgorithm = AceType::MakeRefPtr(); + auto maxHeight = + sheetPageLayoutAlgorithm->ComputeMaxHeight(parentConstraintHeight, parentConstraintWidth, layoutWrapper); + EXPECT_FLOAT_EQ(maxHeight, 90.0f); +} + +/** + * @tc.name: ComputePopupStyleOffset002 + * @tc.desc: ComputeMaxHeight + * @tc.type: FUNC + */ +HWTEST_F(SheetShowInSubwindowTestNg, ComputePopupStyleOffset002, TestSize.Level1) +{ + float parentConstraintHeight = 100.0f; + float parentConstraintWidth = 100.0f; + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto* layoutWrapper = + new LayoutWrapperNode(sheetNode, sheetNode->GetGeometryNode(), sheetNode->GetLayoutProperty()); + ASSERT_NE(layoutWrapper, nullptr); + auto sheetPageLayoutAlgorithm = AceType::MakeRefPtr(); + sheetPageLayoutAlgorithm->sheetStyle_.showInSubWindow = false; + auto maxHeight = + sheetPageLayoutAlgorithm->ComputeMaxHeight(parentConstraintHeight, parentConstraintWidth, layoutWrapper); + EXPECT_FLOAT_EQ(maxHeight, 90.0f); +} + +/** + * @tc.name: ComputePopupStyleOffset003 + * @tc.desc: ComputeMaxHeight + * @tc.type: FUNC + */ +HWTEST_F(SheetShowInSubwindowTestNg, ComputePopupStyleOffset003, TestSize.Level1) +{ + float parentConstraintHeight = 100.0f; + float parentConstraintWidth = 100.0f; + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto* layoutWrapper = + new LayoutWrapperNode(sheetNode, sheetNode->GetGeometryNode(), sheetNode->GetLayoutProperty()); + ASSERT_NE(layoutWrapper, nullptr); + auto sheetPageLayoutAlgorithm = AceType::MakeRefPtr(); + sheetPageLayoutAlgorithm->sheetStyle_.showInSubWindow = false; + auto maxHeight = + sheetPageLayoutAlgorithm->ComputeMaxHeight(parentConstraintHeight, parentConstraintWidth, layoutWrapper); + EXPECT_FLOAT_EQ(maxHeight, 90.0f); +} } // namespace OHOS::Ace::NG \ No newline at end of file -- Gitee From df3885b8c4577645efa4756c20284f0dd8b9133b Mon Sep 17 00:00:00 2001 From: liuyongkai2 Date: Wed, 23 Jul 2025 17:02:33 +0800 Subject: [PATCH 2/2] fix:add tdd Signed-off-by: liuyongkai2 --- .../sheet_presentation_test_four_ng.cpp | 375 +++++++- test/unittest/core/pattern/tabs/BUILD.gn | 1 + .../tabs/tab_bar_pattern_test_three_ng.cpp | 862 ++++++++++++++++++ 3 files changed, 1230 insertions(+), 8 deletions(-) create mode 100644 test/unittest/core/pattern/tabs/tab_bar_pattern_test_three_ng.cpp diff --git a/test/unittest/core/pattern/overlay/sheet_presentation_test_four_ng.cpp b/test/unittest/core/pattern/overlay/sheet_presentation_test_four_ng.cpp index 77386b54e42..39de8bcf8f4 100644 --- a/test/unittest/core/pattern/overlay/sheet_presentation_test_four_ng.cpp +++ b/test/unittest/core/pattern/overlay/sheet_presentation_test_four_ng.cpp @@ -36,6 +36,7 @@ #include "core/components_ng/pattern/scroll/scroll_pattern.h" #include "core/components_ng/pattern/stage/page_pattern.h" #include "core/components_ng/pattern/text/text_layout_property.h" +#include "core/components_ng/pattern/text_field/text_field_manager.h" using namespace testing; using namespace testing::ext; @@ -1269,10 +1270,9 @@ HWTEST_F(SheetPresentationTestFourNg, HandleTouchDown001, TestSize.Level1) SheetPresentationTestFourNg::SetUpTestCase(); TouchLocationInfo info(fingerId); info.globalLocation_ = Offset(100.0f, 100.0f); - auto dragBarNode = - FrameNode::CreateFrameNode("SheetDragBarNode", 04, AceType::MakeRefPtr()); + auto dragBarNode = FrameNode::CreateFrameNode("SheetDragBarNode", 04, AceType::MakeRefPtr()); ASSERT_NE(dragBarNode, nullptr); - auto dragBarPattern = dragBarNode->GetPattern(); + auto dragBarPattern = dragBarNode->GetPattern(); ASSERT_NE(dragBarPattern, nullptr); dragBarPattern->HandleTouchDown(info); EXPECT_FLOAT_EQ(dragBarPattern->downPoint_.GetX(), 100.0f); @@ -1314,9 +1314,9 @@ HWTEST_F(SheetPresentationTestFourNg, GetContentDrawFunction002, TestSize.Level1 ASSERT_NE(sheetPattern, nullptr); auto sheetPaintWrapper = new PaintWrapper( columnNode->GetRenderContext(), sheetNode->GetGeometryNode(), sheetNode->GetPaintProperty()); - SheetDragBarPaintMethod sheetdragbarpaintmethod; - auto paintFunc = sheetdragbarpaintmethod.GetContentDrawFunction(sheetPaintWrapper); - EXPECT_NE(paintFunc, nullptr); + SheetDragBarPaintMethod sheetdragbarpaintmethod; + auto paintFunc = sheetdragbarpaintmethod.GetContentDrawFunction(sheetPaintWrapper); + EXPECT_NE(paintFunc, nullptr); SheetPresentationTestFourNg::TearDownTestCase(); } @@ -1376,7 +1376,7 @@ HWTEST_F(SheetPresentationTestFourNg, GetAvoidKeyboardModeByDefault002, TestSize HWTEST_F(SheetPresentationTestFourNg, DirtyLayoutProcess001, TestSize.Level1) { SheetPresentationTestFourNg::SetUpTestCase(); - auto callback = [](const std::string&) {}; + auto callback = [](const std::string&) {}; auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr(0, "", std::move(callback))); ASSERT_NE(sheetNode, nullptr); @@ -1406,7 +1406,7 @@ HWTEST_F(SheetPresentationTestFourNg, DirtyLayoutProcess001, TestSize.Level1) HWTEST_F(SheetPresentationTestFourNg, DirtyLayoutProcess002, TestSize.Level1) { SheetPresentationTestFourNg::SetUpTestCase(); - auto callback = [](const std::string&) {}; + auto callback = [](const std::string&) {}; auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr(0, "", std::move(callback))); ASSERT_NE(sheetNode, nullptr); @@ -1841,4 +1841,363 @@ HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForLTR001, TestSize.Level1) EXPECT_NE(sheetPattern->onWidthDidChange_, nullptr); SheetPresentationTestFourNg::TearDownTestCase(); } + +/** + * @tc.name: HandleDragEndForLTR002 + * @tc.desc: HandleDragEndForLTR + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForLTR002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + float dragVelocity = 500.0f; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 1.0f; + sheetObject->sheetWidth_ = 10.0f; + AnimationOption option; + object->HandleDragEndForLTR(dragVelocity); + EXPECT_EQ(option.fillMode_, FillMode::FORWARDS); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragEndForLTR003 + * @tc.desc: HandleDragEndForLTR + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForLTR003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + float dragVelocity = -1500.0f; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 1.0f; + sheetObject->sheetWidth_ = 10.0f; + AnimationOption option; + object->HandleDragEndForLTR(dragVelocity); + EXPECT_EQ(option.fillMode_, FillMode::FORWARDS); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragEndForLTR004 + * @tc.desc: HandleDragEndForLTR + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForLTR004, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + float dragVelocity = 1500.0f; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 10.0f; + sheetObject->sheetWidth_ = 10.0f; + AnimationOption option; + object->HandleDragEndForLTR(dragVelocity); + EXPECT_TRUE(sheetPattern->isDirectionUp_); + EXPECT_NE(sheetPattern->onWidthDidChange_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragEndForRTL001 + * @tc.desc: HandleDragEndForRTL + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForRTL001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + float dragVelocity = 500.0f; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 10.0f; + sheetObject->sheetWidth_ = 10.0f; + AnimationOption option; + object->HandleDragEndForRTL(dragVelocity); + EXPECT_TRUE(sheetPattern->isDirectionUp_); + EXPECT_NE(sheetPattern->onWidthDidChange_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragEndForRTL002 + * @tc.desc: HandleDragEndForRTL + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForRTL002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + float dragVelocity = 500.0f; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 1.0f; + sheetObject->sheetWidth_ = 10.0f; + AnimationOption option; + object->HandleDragEndForRTL(dragVelocity); + EXPECT_EQ(option.fillMode_, FillMode::FORWARDS); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragEndForRTL003 + * @tc.desc: HandleDragEndForRTL + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForRTL003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + float dragVelocity = -1500.0f; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 10.0f; + sheetObject->sheetWidth_ = 10.0f; + AnimationOption option; + object->HandleDragEndForRTL(dragVelocity); + EXPECT_TRUE(sheetPattern->isDirectionUp_); + EXPECT_NE(sheetPattern->onWidthDidChange_, nullptr); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: HandleDragEndForRTL004 + * @tc.desc: HandleDragEndForRTL + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, HandleDragEndForRTL004, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + + float dragVelocity = 1500.0f; + auto sheetObject = sheetPattern->GetSheetObject(); + ASSERT_NE(sheetObject, nullptr); + sheetObject->currentOffset_ = 10.0f; + sheetObject->sheetWidth_ = 10.0f; + AnimationOption option; + object->HandleDragEndForRTL(dragVelocity); + EXPECT_EQ(option.fillMode_, FillMode::FORWARDS); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetUpOffsetCaretNeed001 + * @tc.desc: GetUpOffsetCaretNeed + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetUpOffsetCaretNeed001, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto pipeline = PipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + auto manager = pipeline->GetSafeAreaManager(); + ASSERT_NE(manager, nullptr); + manager->keyboardAvoidMode_ = KeyBoardAvoidMode::OFFSET; + manager->keyboardInset_.start = 0; + manager->keyboardInset_.end = 0; + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + auto height = object->GetUpOffsetCaretNeed(); + EXPECT_EQ(height, 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetUpOffsetCaretNeed002 + * @tc.desc: GetUpOffsetCaretNeed + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetUpOffsetCaretNeed002, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto pipeline = PipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + auto manager = pipeline->GetSafeAreaManager(); + ASSERT_NE(manager, nullptr); + manager->keyboardAvoidMode_ = KeyBoardAvoidMode::OFFSET_WITH_CARET; + manager->keyboardInset_.start = 0; + manager->keyboardInset_.end = 10; + manager->systemSafeArea_.bottom_.start = 0; + manager->systemSafeArea_.bottom_.end = 10; + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + auto height = object->GetUpOffsetCaretNeed(); + EXPECT_EQ(height, 20); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetUpOffsetCaretNeed003 + * @tc.desc: GetUpOffsetCaretNeed + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetUpOffsetCaretNeed003, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto pipeline = PipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + auto manager = pipeline->GetSafeAreaManager(); + ASSERT_NE(manager, nullptr); + manager->keyboardAvoidMode_ = KeyBoardAvoidMode::OFFSET; + manager->keyboardInset_.start = 0; + manager->keyboardInset_.end = 10; + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + auto textFieldManager = AceType::DynamicCast(pipeline->GetTextFieldManager()); + auto height = object->GetUpOffsetCaretNeed(); + EXPECT_EQ(height, 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetUpOffsetCaretNeed003 + * @tc.desc: GetUpOffsetCaretNeed + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetUpOffsetCaretNeed004, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto pipeline = PipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + auto manager = pipeline->GetSafeAreaManager(); + ASSERT_NE(manager, nullptr); + manager->keyboardAvoidMode_ = KeyBoardAvoidMode::OFFSET_WITH_CARET; + manager->keyboardInset_.start = 0; + manager->keyboardInset_.end = 10; + manager->systemSafeArea_.bottom_.start = 0; + manager->systemSafeArea_.bottom_.end = 10; + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + auto textFieldManager = AceType::DynamicCast(pipeline->GetTextFieldManager()); + textFieldManager->optionalPosition_ = Offset { 10.0f, 20.0f }; + auto height = object->GetUpOffsetCaretNeed(); + EXPECT_EQ(height, 20); + SheetPresentationTestFourNg::TearDownTestCase(); +} + +/** + * @tc.name: GetUpOffsetCaretNeed003 + * @tc.desc: GetUpOffsetCaretNeed + * @tc.type: FUNC + */ +HWTEST_F(SheetPresentationTestFourNg, GetUpOffsetCaretNeed005, TestSize.Level1) +{ + SheetPresentationTestFourNg::SetUpTestCase(); + auto callback = [](const std::string&) {}; + auto sheetNode = FrameNode::CreateFrameNode(V2::SHEET_PAGE_TAG, ElementRegister::GetInstance()->MakeUniqueId(), + AceType::MakeRefPtr(0, "", std::move(callback))); + ASSERT_NE(sheetNode, nullptr); + auto sheetPattern = sheetNode->GetPattern(); + ASSERT_NE(sheetPattern, nullptr); + auto pipeline = PipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + auto manager = pipeline->GetSafeAreaManager(); + ASSERT_NE(manager, nullptr); + manager->keyboardAvoidMode_ = KeyBoardAvoidMode::OFFSET_WITH_CARET; + manager->keyboardInset_.start = 0; + manager->keyboardInset_.end = 10; + manager->systemSafeArea_.bottom_.start = 0; + manager->systemSafeArea_.bottom_.end = 10; + auto object = AceType::DynamicCast(sheetPattern->GetSheetObject()); + CHECK_NULL_VOID(object); + auto textFieldManager = AceType::DynamicCast(pipeline->GetTextFieldManager()); + textFieldManager->optionalPosition_ = Offset { 10.0f, 20.0f }; + pipeline->rootHeight_ = 100; + textFieldManager->height_ = 10; + auto height = object->GetUpOffsetCaretNeed(); + EXPECT_EQ(height, 0.0f); + SheetPresentationTestFourNg::TearDownTestCase(); +} } // namespace OHOS::Ace::NG \ No newline at end of file diff --git a/test/unittest/core/pattern/tabs/BUILD.gn b/test/unittest/core/pattern/tabs/BUILD.gn index 8714b17e59a..99b416c72d4 100644 --- a/test/unittest/core/pattern/tabs/BUILD.gn +++ b/test/unittest/core/pattern/tabs/BUILD.gn @@ -21,6 +21,7 @@ ace_unittest("tabs_test_ng") { "tab_bar_modifier_test_ng.cpp", "tab_bar_pattern_test_ng.cpp", "tab_bar_pattern_testtwo_ng.cpp", + "tab_bar_pattern_test_three_ng.cpp", "tab_bar_test_ng.cpp", "tab_bar_universal_attributes_test_ng.cpp", "tabs_accessibility_test_ng.cpp", diff --git a/test/unittest/core/pattern/tabs/tab_bar_pattern_test_three_ng.cpp b/test/unittest/core/pattern/tabs/tab_bar_pattern_test_three_ng.cpp new file mode 100644 index 00000000000..6645fa3297c --- /dev/null +++ b/test/unittest/core/pattern/tabs/tab_bar_pattern_test_three_ng.cpp @@ -0,0 +1,862 @@ +/* + * Copyright (c) 2024-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 "tabs_test_ng.h" +#include "test/mock/base/mock_task_executor.h" + +#include "core/components_ng/pattern/text/text_layout_property.h" + +namespace OHOS::Ace::NG { +class TabBarPatternThreeTestNg : public TabsTestNg { +public: + static void SetUpTestSuite(); + static void TearDownTestSuite(); +}; + +void TabBarPatternThreeTestNg::SetUpTestSuite() +{ + TabsTestNg::SetUpTestSuite(); + MockAnimationManager::Enable(true); + const int32_t ticks = 2; + MockAnimationManager::GetInstance().SetTicks(ticks); +} + +void TabBarPatternThreeTestNg::TearDownTestSuite() +{ + TabsTestNg::TearDownTestSuite(); + MockAnimationManager::GetInstance().Reset(); + MockAnimationManager::Enable(false); +} + +/** + * @tc.name: StartShowTabBarImmediately001 + * @tc.desc: test StartShowTabBarImmediately + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, StartShowTabBarImmediately001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + tabBarPattern->userDefinedTranslateY_ = 0.0f; + auto context = tabBarNode->GetRenderContext(); + ASSERT_NE(context, nullptr); + tabBarPattern->StartShowTabBarImmediately(); + tabBarPattern->userDefinedTranslateY_ = 10.0f; + EXPECT_FALSE(tabBarPattern->isTabBarShowing_); +} + +/** + * @tc.name: InsideTabBarRegion001 + * @tc.desc: test InsideTabBarRegion + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, InsideTabBarRegion001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + TouchLocationInfo touchLocationInfo(0); + touchLocationInfo.localLocation_ = Offset(10.0f, 10.0f); + auto geometryNode = tabBarNode->GetGeometryNode(); + ASSERT_NE(geometryNode, nullptr); + auto rectf = geometryNode->frame_.rect_; + rectf = RectF(0.0f, 0.0f, 100.0f, 50.0f); + + auto touchPoint = PointF(10.0f, 10.0f); + auto ret = rectf.IsInRegion(touchPoint); + EXPECT_TRUE(ret); + + auto res = tabBarPattern->InsideTabBarRegion(touchLocationInfo); + EXPECT_TRUE(res); +} + +/** + * @tc.name: GetCurrentFocusNode001 + * @tc.desc: test GetCurrentFocusNode + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetCurrentFocusNode001, TestSize.Level1) +{ + auto tabBarPattern = AceType::MakeRefPtr(); + ASSERT_NE(tabBarPattern, nullptr); + + auto childFocusHub = tabBarPattern->GetCurrentFocusNode(); + CHECK_NULL_VOID(childFocusHub); + EXPECT_EQ(childFocusHub->GetFocusDependence(), FocusDependence::SELF); +} + +/** + * @tc.name: GetNextFocusIndicator001 + * @tc.desc: test GetNextFocusIndicator + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetNextFocusIndicator001, TestSize.Level1) +{ + int32_t indicator = -1; + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto indicator1 = tabBarPattern->GetNextFocusIndicator(indicator, FocusStep::SHIFT_TAB); + EXPECT_EQ(indicator1, std::nullopt); +} + +/** + * @tc.name: GetNextFocusIndicator002 + * @tc.desc: test GetNextFocusIndicator + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetNextFocusIndicator002, TestSize.Level1) +{ + int32_t indicator = 1; + + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto indicator1 = tabBarPattern->GetNextFocusIndicator(indicator, FocusStep::SHIFT_TAB); + EXPECT_EQ(indicator1, 0); +} + +/** + * @tc.name: GetNextFocusIndicator003 + * @tc.desc: test GetNextFocusIndicator + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetNextFocusIndicator003, TestSize.Level1) +{ + int32_t indicator = 1; + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto indicator1 = tabBarPattern->GetNextFocusIndicator(indicator, FocusStep::TAB); + EXPECT_EQ(indicator1, 2); +} + +/** + * @tc.name: GetNextFocusIndicator004 + * @tc.desc: test GetNextFocusIndicator + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetNextFocusIndicator004, TestSize.Level1) +{ + int32_t indicator = 1; + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto indicator1 = tabBarPattern->GetNextFocusIndicator(indicator, FocusStep::UP_END); + EXPECT_EQ(indicator1, 0); +} + +/** + * @tc.name: SetSurfaceChangeCallback001 + * @tc.desc: test SetSurfaceChangeCallback + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, SetSurfaceChangeCallback001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + tabBarPattern->SetSurfaceChangeCallback(); + EXPECT_NE(tabBarPattern->swiperController_, nullptr); +} + +/** + * @tc.name: CustomizeExpandSafeArea001 + * @tc.desc: test CustomizeExpandSafeArea + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, CustomizeExpandSafeArea001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto res = tabBarPattern->CustomizeExpandSafeArea(); + EXPECT_TRUE(res); +} + +/** + * @tc.name: CustomizeExpandSafeArea002 + * @tc.desc: test CustomizeExpandSafeArea + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, CustomizeExpandSafeArea002, TestSize.Level1) +{ + auto tabBarPattern = AceType::MakeRefPtr(); + ASSERT_NE(tabBarPattern, nullptr); + + auto res = tabBarPattern->CustomizeExpandSafeArea(); + EXPECT_FALSE(res); +} + +/** + * @tc.name: ClickTo001 + * @tc.desc: test ClickTo + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, ClickTo001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabPattern = tabsNode->GetPattern(); + ASSERT_NE(tabPattern, nullptr); + auto host = FrameNode::CreateFrameNode(V2::TABS_ETS_TAG, -1, tabPattern, true); + ASSERT_NE(host, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPattern = swiperNode->GetPattern(); + ASSERT_NE(swiperPattern, nullptr); + tabsNode->AddChild(host); + + tabPattern->isCustomAnimation_ = true; + swiperPattern->currentProxyInAnimation_ = AceType::MakeRefPtr(); + + int32_t index1 = 10; + tabBarPattern->ClickTo(host, index1); + EXPECT_EQ(swiperPattern->customAnimationToIndex_, 10); +} + +/** + * @tc.name: ClickTo002 + * @tc.desc: test ClickTo + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, ClickTo002, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabPattern = tabsNode->GetPattern(); + ASSERT_NE(tabPattern, nullptr); + auto host = FrameNode::CreateFrameNode(V2::TABS_ETS_TAG, -1, tabPattern, true); + ASSERT_NE(host, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPattern = swiperNode->GetPattern(); + ASSERT_NE(swiperPattern, nullptr); + + tabsNode->AddChild(host); + + tabPattern->isCustomAnimation_ = false; + tabBarPattern->animationDuration_ = 300; + tabPattern->animateMode_ = TabAnimateMode::ACTION_FIRST; + swiperPattern->currentProxyInAnimation_ = AceType::MakeRefPtr(); + int32_t index1 = 10; + + tabBarPattern->ClickTo(host, index1); + EXPECT_TRUE(tabBarPattern->tabContentWillChangeFlag_); +} + +/** + * @tc.name: ClickTo003 + * @tc.desc: test ClickTo + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, ClickTo003, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabPattern = tabsNode->GetPattern(); + ASSERT_NE(tabPattern, nullptr); + auto host = FrameNode::CreateFrameNode(V2::TABS_ETS_TAG, -1, tabPattern, true); + ASSERT_NE(host, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPattern = swiperNode->GetPattern(); + ASSERT_NE(swiperPattern, nullptr); + + tabsNode->AddChild(host); + + tabPattern->isCustomAnimation_ = false; + tabBarPattern->animationDuration_ = 300; + tabPattern->animateMode_ = TabAnimateMode::NO_ANIMATION; + swiperPattern->currentProxyInAnimation_ = AceType::MakeRefPtr(); + int32_t index1 = 10; + bool isCallbackCalled = false; + + tabBarPattern->swiperController_->SetSwipeToWithoutAnimationImpl([&](int32_t index) { isCallbackCalled = true; }); + tabBarPattern->ClickTo(host, index1); + EXPECT_TRUE(isCallbackCalled); +} + +/** + * @tc.name: ClickTo004 + * @tc.desc: test ClickTo + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, ClickTo004, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabPattern = tabsNode->GetPattern(); + ASSERT_NE(tabPattern, nullptr); + auto host = FrameNode::CreateFrameNode(V2::TABS_ETS_TAG, -1, tabPattern, true); + ASSERT_NE(host, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPattern = swiperNode->GetPattern(); + ASSERT_NE(swiperPattern, nullptr); + auto tabBarLayoutProperty = tabBarNode->GetLayoutProperty(); + ASSERT_NE(tabBarLayoutProperty, nullptr); + + tabsNode->AddChild(host); + + tabPattern->isCustomAnimation_ = true; + tabBarPattern->animationDuration_ = 300; + int32_t index1 = 10; + tabBarLayoutProperty->UpdateTabBarMode(TabBarMode::SCROLLABLE); + tabBarPattern->visibleItemPosition_ = { { 1, { 100, true } }, { 2, { 200, false } } }; + + tabBarPattern->ClickTo(host, index1); + EXPECT_EQ(tabBarPattern->targetIndex_, index1); +} + +/** + * @tc.name: ClickTo005 + * @tc.desc: test ClickTo + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, ClickTo005, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabPattern = tabsNode->GetPattern(); + ASSERT_NE(tabPattern, nullptr); + auto host = FrameNode::CreateFrameNode(V2::TABS_ETS_TAG, -1, tabPattern, true); + ASSERT_NE(host, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPattern = swiperNode->GetPattern(); + ASSERT_NE(swiperPattern, nullptr); + auto tabBarLayoutProperty = tabBarNode->GetLayoutProperty(); + ASSERT_NE(tabBarLayoutProperty, nullptr); + + tabsNode->AddChild(host); + + tabPattern->isCustomAnimation_ = true; + tabBarPattern->animationDuration_ = 300; + int32_t index1 = 10; + + tabBarPattern->ClickTo(host, index1); + EXPECT_EQ(tabBarPattern->jumpIndex_, index1); +} + +/** + * @tc.name: ClickTo006 + * @tc.desc: test ClickTo + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, ClickTo006, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabPattern = tabsNode->GetPattern(); + ASSERT_NE(tabPattern, nullptr); + auto host = FrameNode::CreateFrameNode(V2::TABS_ETS_TAG, -1, tabPattern, true); + ASSERT_NE(host, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPattern = swiperNode->GetPattern(); + ASSERT_NE(swiperPattern, nullptr); + auto tabBarLayoutProperty = tabBarNode->GetLayoutProperty(); + ASSERT_NE(tabBarLayoutProperty, nullptr); + tabsNode->AddChild(host); + + tabPattern->isCustomAnimation_ = true; + tabBarPattern->animationDuration_ = 300; + int32_t index1 = 10; + auto pipeline = tabsNode->GetContext(); + ASSERT_NE(pipeline, nullptr); + auto tabTheme = pipeline->GetTheme(); + ASSERT_NE(tabTheme, nullptr); + tabTheme->isChangeFocusTextStyle_ = true; + + tabBarPattern->ClickTo(host, index1); + EXPECT_EQ(tabBarPattern->focusIndicator_, index1); +} + +/** + * @tc.name: IsContainsBuilder001 + * @tc.desc: test IsContainsBuilder + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, IsContainsBuilder001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + tabBarPattern->tabBarType_.clear(); + EXPECT_FALSE(tabBarPattern->IsContainsBuilder()); +} + +/** + * @tc.name: IsContainsBuilder002 + * @tc.desc: test IsContainsBuilder + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, IsContainsBuilder002, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + int32_t tabs = 1; + + tabBarPattern->tabBarType_.emplace(tabs, TabBarParamType::CUSTOM_BUILDER); + EXPECT_TRUE(tabBarPattern->IsContainsBuilder()); +} + +/** + * @tc.name: IsContainsBuilder003 + * @tc.desc: test IsContainsBuilder + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, IsContainsBuilder003, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + int32_t tabs = 1; + tabBarPattern->tabBarType_.emplace(tabs, TabBarParamType::COMPONENT_CONTENT); + tabBarPattern->tabBarType_.emplace(tabs, TabBarParamType::SUB_COMPONENT_CONTENT); + + EXPECT_TRUE(tabBarPattern->IsContainsBuilder()); +} + +/** + * @tc.name: IsContainsBuilder004 + * @tc.desc: test IsContainsBuilder + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, IsContainsBuilder004, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + int32_t tabs = 1; + + tabBarPattern->tabBarType_.emplace(tabs, TabBarParamType::NORMAL); + tabBarPattern->tabBarType_.emplace(tabs, TabBarParamType::SUB_COMPONENT_CONTENT); + + EXPECT_FALSE(tabBarPattern->IsContainsBuilder()); +} + +/** + * @tc.name: OnCustomContentTransition001 + * @tc.desc: test OnCustomContentTransition + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, OnCustomContentTransition001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPattern = swiperNode->GetPattern(); + ASSERT_NE(swiperPattern, nullptr); + int32_t fromIndex = 1; + int32_t toIndex = 10; + tabBarPattern->OnCustomContentTransition(fromIndex, toIndex); + + EXPECT_EQ(swiperPattern->customAnimationToIndex_, toIndex); +} + +/** + * @tc.name: GetSwiperPattern001 + * @tc.desc: test GetSwiperPattern + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetSwiperPattern001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto swiperPattern = tabBarPattern->GetSwiperPattern(); + EXPECT_NE(swiperPattern, nullptr); +} + +/** + * @tc.name: SetSwiperCurve001 + * @tc.desc: test SetSwiperCurve + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, SetSwiperCurve001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPaintProperty = swiperNode->GetPaintProperty(); + ASSERT_NE(swiperPaintProperty, nullptr); + + RefPtr expectedCurve = AceType::MakeRefPtr(0.25f, 0.1f, 0.25f, 1.0f); + + tabBarPattern->SetSwiperCurve(expectedCurve); + EXPECT_EQ(swiperPaintProperty->GetCurveValue(nullptr), expectedCurve); +} + +/** + * @tc.name: SetTurnPageRateCallback001 + * @tc.desc: test SetTurnPageRateCallback + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, SetTurnPageRateCallback001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto swiperNode = AceType::DynamicCast(tabsNode->GetTabs()); + ASSERT_NE(swiperNode, nullptr); + auto swiperPattern = swiperNode->GetPattern(); + ASSERT_NE(swiperPattern, nullptr); + auto swiperController = swiperPattern->GetSwiperController(); + ASSERT_NE(swiperController, nullptr); + + tabBarPattern->swiperController_ = swiperController; + tabBarPattern->isTouchingSwiper_ = true; + tabBarPattern->SetSurfaceChangeCallback(); + EXPECT_FALSE(tabBarPattern->isTouchingSwiper_); +} + +/** + * @tc.name: UpdateChildrenClipEdge001 + * @tc.desc: test UpdateChildrenClipEdge + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, UpdateChildrenClipEdge001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto pipeline = tabsNode->GetContext(); + ASSERT_NE(pipeline, nullptr); + auto tabTheme = pipeline->GetTheme(); + ASSERT_NE(tabTheme, nullptr); + + tabTheme->isChangeFocusTextStyle_ = true; + tabBarPattern->UpdateChildrenClipEdge(); + EXPECT_FALSE(tabBarPattern->clipEdge_); +} + +/** + * @tc.name: UpdateChildrenClipEdge002 + * @tc.desc: test UpdateChildrenClipEdge + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, UpdateChildrenClipEdge002, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto pipeline = tabsNode->GetContext(); + ASSERT_NE(pipeline, nullptr); + auto tabTheme = pipeline->GetTheme(); + ASSERT_NE(tabTheme, nullptr); + + tabTheme->isChangeFocusTextStyle_ = false; + tabBarPattern->UpdateChildrenClipEdge(); + EXPECT_TRUE(tabBarPattern->clipEdge_); +} + +/** + * @tc.name: ShowDialogWithNode001 + * @tc.desc: test ShowDialogWithNode + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, ShowDialogWithNode001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto pipeline = tabsNode->GetContext(); + ASSERT_NE(pipeline, nullptr); + auto tabTheme = pipeline->GetTheme(); + ASSERT_NE(tabTheme, nullptr); + + tabTheme->isChangeFocusTextStyle_ = false; + tabBarPattern->UpdateChildrenClipEdge(); + EXPECT_TRUE(tabBarPattern->clipEdge_); +} + +/** + * @tc.name: UpdateCurrentOffset001 + * @tc.desc: test UpdateCurrentOffset + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, UpdateCurrentOffset001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + float offset = 0.0f; + tabBarPattern->clickRepeat_ = true; + tabBarPattern->UpdateCurrentOffset(offset); + EXPECT_EQ(tabBarPattern->currentDelta_, offset); + EXPECT_TRUE(tabBarPattern->clickRepeat_); +} + +/** + * @tc.name: UpdateCurrentOffset002 + * @tc.desc: test UpdateCurrentOffset + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, UpdateCurrentOffset002, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + float offset = 10.0f; + tabBarPattern->clickRepeat_ = true; + tabBarPattern->UpdateCurrentOffset(offset); + EXPECT_EQ(tabBarPattern->currentDelta_, offset); + EXPECT_FALSE(tabBarPattern->clickRepeat_); +} + +/** + * @tc.name: GetTabBarBackgroundColor001 + * @tc.desc: test GetTabBarBackgroundColor + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetTabBarBackgroundColor001, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto context = tabBarNode->GetRenderContext(); + ASSERT_NE(context, nullptr); + + context->propBackgroundColor_ = Color::RED; + EXPECT_TRUE(context->HasBackgroundColor()); + + auto color = tabBarPattern->GetTabBarBackgroundColor(); + EXPECT_EQ(color, Color::RED); +} + +/** + * @tc.name: GetTabBarBackgroundColor002 + * @tc.desc: test GetTabBarBackgroundColor + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetTabBarBackgroundColor002, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto context = tabsNode->GetRenderContext(); + ASSERT_NE(context, nullptr); + + context->propBackgroundColor_ = Color::BLUE; + EXPECT_TRUE(context->HasBackgroundColor()); + + auto color = tabBarPattern->GetTabBarBackgroundColor(); + EXPECT_EQ(color, Color::BLUE); +} + +/** + * @tc.name: GetTabBarBackgroundColor003 + * @tc.desc: test GetTabBarBackgroundColor + * @tc.type: FUNC + */ +HWTEST_F(TabBarPatternThreeTestNg, GetTabBarBackgroundColor003, TestSize.Level1) +{ + RefPtr element = ViewStackProcessor::GetInstance()->GetMainElementNode(); + CHECK_NULL_VOID(element); + auto tabsNode = AceType::DynamicCast(element); + ASSERT_NE(tabsNode, nullptr); + auto tabBarNode = AceType::DynamicCast(tabsNode->GetTabBar()); + ASSERT_NE(tabBarNode, nullptr); + auto tabBarPattern = tabBarNode->GetPattern(); + ASSERT_NE(tabBarPattern, nullptr); + + auto pipeline = tabBarNode->GetContext(); + ASSERT_NE(pipeline, nullptr); + auto tabTheme = pipeline->GetTheme(); + ASSERT_NE(tabTheme, nullptr); + + tabTheme->backgroundColor_ = Color::GREEN; + + auto color = tabBarPattern->GetTabBarBackgroundColor(); + EXPECT_EQ(color, Color::GREEN); +} +} // namespace OHOS::Ace::NG -- Gitee