From c873babe2a3df45303ed95fdf5cd47d19050163c Mon Sep 17 00:00:00 2001 From: shuangshuangliu Date: Wed, 20 Aug 2025 11:17:52 +0800 Subject: [PATCH] =?UTF-8?q?TDD=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shuangshuangliu Change-Id: Ibf43d925191a2cdaf9591ec5b2d02ef88f6b59a2 --- wm/test/unittest/BUILD.gn | 18 + .../picture_in_picture_manager_new_test.cpp | 520 ++++++++++++++++++ 2 files changed, 538 insertions(+) create mode 100644 wm/test/unittest/picture_in_picture_manager_new_test.cpp diff --git a/wm/test/unittest/BUILD.gn b/wm/test/unittest/BUILD.gn index 6a9fca35b8..0b6bae4080 100644 --- a/wm/test/unittest/BUILD.gn +++ b/wm/test/unittest/BUILD.gn @@ -29,6 +29,7 @@ group("unittest") { ":wm_pattern_detach_callback_proxy_test", ":wm_pattern_detach_callback_test", ":wm_picture_in_picture_controller_test", + ":wm_picture_in_picture_manager_new_test", ":wm_picture_in_picture_manager_test", ":wm_picture_in_picture_option_test", ":wm_root_scene_test", @@ -572,6 +573,23 @@ ohos_unittest("wm_picture_in_picture_manager_test") { ] } +ohos_unittest("wm_picture_in_picture_manager_new_test") { + module_out_path = module_out_path + + sources = [ "picture_in_picture_manager_new_test.cpp" ] + + deps = [ + ":wm_unittest_common", + "${window_base_path}/window_scene/interfaces/innerkits:libwsutils", + ] + + external_deps = test_external_deps + external_deps += [ + "ability_runtime:runtime", + "ace_engine:ace_xcomponent_controller", + ] +} + ohos_unittest("wm_picture_in_picture_option_test") { module_out_path = module_out_path diff --git a/wm/test/unittest/picture_in_picture_manager_new_test.cpp b/wm/test/unittest/picture_in_picture_manager_new_test.cpp new file mode 100644 index 0000000000..dca73d8200 --- /dev/null +++ b/wm/test/unittest/picture_in_picture_manager_new_test.cpp @@ -0,0 +1,520 @@ +/* + * Copyright (c) 2023-2023 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 "picture_in_picture_manager.h" +#include "scene_board_judgement.h" +#include "singleton_container.h" +#include "window_scene_session_impl.h" +#include "wm_common.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace Rosen { +class PictureInPictureManagerNewTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; + +class MockWindow : public Window { +public: + MockWindow() {}; + ~MockWindow() {}; +}; + +void PictureInPictureManagerNewTest::SetUpTestCase() {} + +void PictureInPictureManagerNewTest::TearDownTestCase() {} + +void PictureInPictureManagerNewTest::SetUp() {} + +void PictureInPictureManagerNewTest::TearDown() {} + +namespace { + +/** + * @tc.name: IsSupportPiP + * @tc.desc: IsSupportPiP + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, IsSupportPiP, TestSize.Level1) +{ + if (SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(true, PictureInPictureManager::IsSupportPiP()); + } else { + EXPECT_EQ(false, PictureInPictureManager::IsSupportPiP()); + } +} + +/** + * @tc.name: PiPWindowState + * @tc.desc: PiPWindowState + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, PiPWindowState001, TestSize.Level1) +{ + sptr option = new PipOption(); + sptr pipController = new PictureInPictureController(option, nullptr, 100, nullptr); + PictureInPictureManager::PutPipControllerInfo(100, pipController); + EXPECT_EQ(1, static_cast(PictureInPictureManager::windowToControllerMap_.size())); + PictureInPictureManager::RemovePipControllerInfo(100); + EXPECT_EQ(0, static_cast(PictureInPictureManager::windowToControllerMap_.size())); +} + +/** + * @tc.name: PiPWindowState + * @tc.desc: PiPWindowState + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, PiPWindowState002, TestSize.Level1) +{ + int32_t source = 0; + std::string errorReason = ""; + SingletonContainer::Get().ReportPiPStartWindow(source, 1, 1, errorReason); + SingletonContainer::Get().ReportPiPStopWindow(source, 1, 1, errorReason); + source = 1; + SingletonContainer::Get().ReportPiPStartWindow(source, 1, 1, errorReason); + SingletonContainer::Get().ReportPiPStopWindow(source, 1, 1, errorReason); + std::string actionEvent = ""; + SingletonContainer::Get().ReportPiPActionEvent(1, actionEvent); + actionEvent = "nextVideo"; + SingletonContainer::Get().ReportPiPActionEvent(1, actionEvent); +} + +/** + * @tc.name: PictureInPictureController + * @tc.desc: PictureInPictureController + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, PictureInPictureController001, TestSize.Level1) +{ + sptr option = new PipOption(); + sptr pipController = new PictureInPictureController(option, nullptr, 100, nullptr); + PictureInPictureManager::activeController_ = nullptr; + EXPECT_FALSE(PictureInPictureManager::HasActiveController()); + PictureInPictureManager::RemoveActiveController(pipController); + EXPECT_FALSE(PictureInPictureManager::HasActiveController()); + EXPECT_FALSE(PictureInPictureManager::IsActiveController(pipController)); +} + +/** + * @tc.name: PictureInPictureController + * @tc.desc: PictureInPictureController + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, PictureInPictureController002, TestSize.Level1) +{ + sptr option = new PipOption(); + sptr pipController = new PictureInPictureController(option, nullptr, 100, nullptr); + PictureInPictureManager::SetActiveController(pipController); + EXPECT_TRUE(PictureInPictureManager::HasActiveController()); + EXPECT_TRUE(PictureInPictureManager::IsActiveController(pipController)); + EXPECT_TRUE(PictureInPictureManager::IsAttachedToSameWindow(100)); + EXPECT_FALSE(PictureInPictureManager::IsAttachedToSameWindow(1)); + PictureInPictureManager::RemoveActiveController(pipController); + EXPECT_FALSE(PictureInPictureManager::HasActiveController()); + EXPECT_FALSE(PictureInPictureManager::IsActiveController(pipController)); +} + +/** + * @tc.name: ShouldAbortPipStart + * @tc.desc: ShouldAbortPipStart + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, ShouldAbortPipStart, TestSize.Level1) +{ + EXPECT_FALSE(PictureInPictureManager::ShouldAbortPipStart()); + + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + PictureInPictureManager::SetActiveController(pipController); + pipController->curState_ = PiPWindowState::STATE_STARTING; + + EXPECT_TRUE(PictureInPictureManager::ShouldAbortPipStart()); +} + +/** + * @tc.name: GetPipControllerInfo + * @tc.desc: GetPipControllerInfo + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, GetPipControllerInfo, TestSize.Level1) +{ + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + PictureInPictureManager::SetActiveController(pipController); + int32_t windowId = 1; + ASSERT_EQ(nullptr, PictureInPictureManager::GetPipControllerInfo(windowId)); + + sptr pipController1 = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController1, nullptr); + PictureInPictureManager::windowToControllerMap_.insert(std::make_pair(windowId, pipController1)); + ASSERT_EQ(pipController1, PictureInPictureManager::GetPipControllerInfo(windowId)); +} + +/** + * @tc.name: GetActiveController + * @tc.desc: GetActiveController + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, GetActiveController001, TestSize.Level1) +{ + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + PictureInPictureManager::SetActiveController(pipController); + ASSERT_EQ(pipController, PictureInPictureManager::GetActiveController()); +} + +/** + * @tc.name: GetActiveController + * @tc.desc: GetActiveController + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, GetActiveController002, TestSize.Level1) +{ + PictureInPictureManager::SetActiveController(nullptr); + ASSERT_EQ(nullptr, PictureInPictureManager::GetActiveController()); +} + +/** + * @tc.name: AttachAutoStartController + * @tc.desc: AttachAutoStartController + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, AttachAutoStartController, TestSize.Level1) +{ + PictureInPictureManager::AttachAutoStartController(0, nullptr); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + PictureInPictureManager::SetActiveController(pipController); + wptr pipController1 = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController1, nullptr); + PictureInPictureManager::AttachAutoStartController(1, pipController1); + ASSERT_EQ(pipController1, PictureInPictureManager::autoStartControllerMap_[1]); +} + +/** + * @tc.name: DetachAutoStartController + * @tc.desc: DetachAutoStartController + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DetachAutoStartController, TestSize.Level1) +{ + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + wptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + wptr pipController1 = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController1, nullptr); + PictureInPictureManager::AttachAutoStartController(0, pipController); + PictureInPictureManager::AttachAutoStartController(1, pipController1); + EXPECT_EQ(2, PictureInPictureManager::autoStartControllerMap_.size()); + PictureInPictureManager::DetachAutoStartController(0, nullptr); + EXPECT_EQ(1, PictureInPictureManager::autoStartControllerMap_.size()); + PictureInPictureManager::DetachAutoStartController(0, pipController); + EXPECT_EQ(1, PictureInPictureManager::autoStartControllerMap_.size()); +} + +/** + * @tc.name: IsAttachedToSameWindow + * @tc.desc: IsAttachedToSameWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, IsAttachedToSameWindow001, TestSize.Level1) +{ + bool res = PictureInPictureManager::IsAttachedToSameWindow(0); + EXPECT_EQ(res, false); +} + +/** + * @tc.name: IsAttachedToSameWindow + * @tc.desc: IsAttachedToSameWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, IsAttachedToSameWindow002, TestSize.Level1) +{ + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + + PictureInPictureManager::activeController_ = nullptr; + EXPECT_FALSE(PictureInPictureManager::HasActiveController()); + bool res1 = PictureInPictureManager::IsAttachedToSameWindow(1); + EXPECT_EQ(res1, false); + + PictureInPictureManager::SetActiveController(pipController); + bool res2 = PictureInPictureManager::IsAttachedToSameWindow(100); + EXPECT_EQ(res2, true); + bool res3 = PictureInPictureManager::IsAttachedToSameWindow(1); + EXPECT_EQ(res3, false); +} + +/** + * @tc.name: GetCurrentWindow + * @tc.desc: GetCurrentWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, GetCurrentWindow001, TestSize.Level1) +{ + ASSERT_EQ(nullptr, PictureInPictureManager::GetCurrentWindow()); +} + +/** + * @tc.name: GetCurrentWindow + * @tc.desc: GetCurrentWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, GetCurrentWindow002, TestSize.Level1) +{ + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + + PictureInPictureManager::activeController_ = nullptr; + EXPECT_FALSE(PictureInPictureManager::HasActiveController()); + ASSERT_EQ(nullptr, PictureInPictureManager::GetCurrentWindow()); + + sptr window = nullptr; + ASSERT_EQ(window, pipController->window_); + PictureInPictureManager::SetActiveController(pipController); + window = PictureInPictureManager::GetCurrentWindow(); + ASSERT_EQ(window, pipController->window_); +} + +/** + * @tc.name: DoPreRestore + * @tc.desc: DoPreRestore + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoPreRestore, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipController = sptr::MakeSptr(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + PictureInPictureManager::SetActiveController(pipController); + PictureInPictureManager::DoPreRestore(); + EXPECT_EQ(pipController->curState_, PiPWindowState::STATE_RESTORING); +} + +/** + * @tc.name: DoPrepareSource + * @tc.desc: DoPrepareSource + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoPrepareSource, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipController = sptr::MakeSptr(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + PictureInPictureManager::activeController_ = nullptr; + PictureInPictureManager::DoPrepareSource(); + PictureInPictureManager::SetActiveController(pipController); + PictureInPictureManager::DoPrepareSource(); +} + +/** + * @tc.name: DoLocateSource + * @tc.desc: DoLocateSource + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoLocateSource, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipController = sptr::MakeSptr(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + PictureInPictureManager::activeController_ = nullptr; + PictureInPictureManager::DoLocateSource(); + PictureInPictureManager::SetActiveController(pipController); + PictureInPictureManager::DoLocateSource(); +} + +/** + * @tc.name: DoRestore + * @tc.desc: DoRestore + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoRestore001, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + pipController->curState_ = PiPWindowState::STATE_STARTED; + PictureInPictureManager::activeController_ = nullptr; + PictureInPictureManager::DoRestore(); + EXPECT_EQ(pipController->curState_, PiPWindowState::STATE_STARTED); +} + +/** + * @tc.name: DoRestore + * @tc.desc: DoRestore + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoRestore002, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + pipController->curState_ = PiPWindowState::STATE_STARTED; + pipController->window_ = mw; + PictureInPictureManager::SetActiveController(pipController); + PictureInPictureManager::DoRestore(); + EXPECT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPING); +} + +/** + * @tc.name: DoClose + * @tc.desc: DoClose + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoClose, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipController = sptr::MakeSptr(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + pipController->curState_ = PiPWindowState::STATE_STARTED; + PictureInPictureManager::activeController_ = nullptr; + EXPECT_EQ(false, PictureInPictureManager::HasActiveController()); + PictureInPictureManager::SetActiveController(pipController); + EXPECT_EQ(true, PictureInPictureManager::HasActiveController()); + PictureInPictureManager::DoClose(true, true); + pipController->window_ = mw; + PictureInPictureManager::DoClose(false, true); + EXPECT_EQ(false, PictureInPictureManager::HasActiveController()); + EXPECT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPED); +} + +/** + * @tc.name: DoActionEvent + * @tc.desc: DoActionEvent + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoActionEvent001, TestSize.Level1) +{ + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipController = sptr::MakeSptr(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + PictureInPictureManager::activeController_ = nullptr; + EXPECT_EQ(false, PictureInPictureManager::HasActiveController()); +} + +/** + * @tc.name: DoActionEvent + * @tc.desc: DoActionEvent + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoActionEvent002, TestSize.Level1) +{ + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipController = sptr::MakeSptr(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + std::string actionName = "test"; + PictureInPictureManager::DoActionEvent(actionName, 0); + PictureInPictureManager::SetActiveController(pipController); + EXPECT_EQ(true, PictureInPictureManager::HasActiveController()); + const std::string ACTION_CLOSE = "close"; + PictureInPictureManager::DoActionEvent(ACTION_CLOSE, 0); +} + +/** + * @tc.name: AutoStartPipWindow + * @tc.desc: AutoStartPipWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, AutoStartPipWindow, TestSize.Level1) +{ + PictureInPictureManager::autoStartController_ = nullptr; + PictureInPictureManager::AutoStartPipWindow(); + + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipController = + new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr); + PictureInPictureManager::autoStartController_ = pipController; + option->SetTypeNodeEnabled(true); + PictureInPictureManager::AutoStartPipWindow(); + option->SetTypeNodeEnabled(false); + PictureInPictureManager::AutoStartPipWindow(); + SingletonContainer::Get().ReportPiPActionEvent(1, "close"); +} + +/** + * @tc.name: DoDestroy + * @tc.desc: DoDestroy + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureManagerNewTest, DoDestroy, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipController = sptr::MakeSptr(option, nullptr, 100, nullptr); + ASSERT_NE(pipController, nullptr); + + PictureInPictureManager::activeController_ = pipController; + pipController->window_ = mw; + PictureInPictureManager::DoDestroy(); + EXPECT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPED); +} +} // namespace +} // namespace Rosen +} // namespace OHOS \ No newline at end of file -- Gitee