From bdc657351b23bb8be251b9fe7e4b83524a035681 Mon Sep 17 00:00:00 2001 From: shuangshuangliu Date: Fri, 15 Aug 2025 17:05:57 +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: I5f04f8df1f27b2766affa18286014cea0aacf750 --- wm/test/unittest/BUILD.gn | 15 + ...picture_in_picture_controller_new_test.cpp | 1690 +++++++++++++++++ 2 files changed, 1705 insertions(+) create mode 100644 wm/test/unittest/picture_in_picture_controller_new_test.cpp diff --git a/wm/test/unittest/BUILD.gn b/wm/test/unittest/BUILD.gn index 56e9391ec6..17e2915fb5 100644 --- a/wm/test/unittest/BUILD.gn +++ b/wm/test/unittest/BUILD.gn @@ -26,6 +26,7 @@ group("unittest") { ":wm_input_transfer_station_test", ":wm_pattern_detach_callback_proxy_test", ":wm_pattern_detach_callback_test", + ":wm_picture_in_picture_controller_new_test", ":wm_picture_in_picture_controller_test", ":wm_picture_in_picture_manager_test", ":wm_picture_in_picture_option_test", @@ -553,6 +554,20 @@ ohos_unittest("wm_picture_in_picture_controller_test") { ] } +ohos_unittest("wm_picture_in_picture_controller_new_test") { + module_out_path = module_out_path + + sources = [ "picture_in_picture_controller_new_test.cpp" ] + + deps = [ ":wm_unittest_common" ] + + external_deps = test_external_deps + external_deps += [ + "ability_runtime:runtime", + "ace_engine:ace_xcomponent_controller", + ] +} + ohos_unittest("wm_picture_in_picture_manager_test") { module_out_path = module_out_path diff --git a/wm/test/unittest/picture_in_picture_controller_new_test.cpp b/wm/test/unittest/picture_in_picture_controller_new_test.cpp new file mode 100644 index 0000000000..35833c9730 --- /dev/null +++ b/wm/test/unittest/picture_in_picture_controller_new_test.cpp @@ -0,0 +1,1690 @@ +/* + * 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 +#include "ability_context_impl.h" +#include "mock_session.h" +#include "modifier_render_thread/rs_modifiers_draw_thread.h" +#include "parameters.h" +#include "picture_in_picture_controller.h" +#include "picture_in_picture_manager.h" +#include "window.h" +#include "window_session_impl.h" +#include "wm_common.h" +#include "xcomponent_controller.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace Rosen { +class MockNewWindow : public Window { +public: + MockNewWindow() {}; + ~MockNewWindow() {}; + MOCK_METHOD3(Show, WMError(uint32_t reason, bool withAnimation, bool withFocus)); + MOCK_METHOD1(Destroy, WMError(uint32_t reason)); + MOCK_METHOD0(NotifyPrepareClosePiPWindow, WMError()); + MOCK_METHOD4(SetAutoStartPiP, void(bool isAutoStart, uint32_t priority, uint32_t width, uint32_t height)); + MOCK_CONST_METHOD0(GetWindowState, WindowState()); +}; + +class MockNewXComponentController : public XComponentController { +public: + MockNewXComponentController() {} + ~MockNewXComponentController() {} + MOCK_METHOD2(GetGlobalPosition, XComponentControllerErrorCode(float& offsetX, float& offsetY)); + MOCK_METHOD2(GetSize, XComponentControllerErrorCode(float& width, float& height)); + MOCK_METHOD1(SetExtController, + XComponentControllerErrorCode(std::shared_ptr xComponentController)); + MOCK_METHOD1(ResetExtController, + XComponentControllerErrorCode(std::shared_ptr xComponentController)); +}; + +class PictureInPictureControllerNewTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +private: + static constexpr uint32_t WAIT_SYNC_IN_NS = 200000; +}; + +void PictureInPictureControllerNewTest::SetUpTestCase() {} + +void PictureInPictureControllerNewTest::TearDownTestCase() +{ +#ifdef RS_ENABLE_VK + RSModifiersDrawThread::Destroy(); +#endif +} + +void PictureInPictureControllerNewTest::SetUp() {} + +void PictureInPictureControllerNewTest::TearDown() {} + +namespace { +/** + * @tc.name: ShowPictureInPictureWindow01 + * @tc.desc: ShowPictureInPictureWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, ShowPictureInPictureWindow01, TestSize.Level1) +{ + StartPipType startType = StartPipType::NULL_START; + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr mw1 = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw1); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->pipOption_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->ShowPictureInPictureWindow(startType)); + pipControl->pipOption_ = option; + + pipControl->window_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->ShowPictureInPictureWindow(startType)); + pipControl->window_ = mw; + + auto listener = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener); + pipControl->RegisterPiPLifecycle(listener); + EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING)); + EXPECT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, pipControl->ShowPictureInPictureWindow(startType)); + EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType)); + EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + startType = StartPipType::AUTO_START; + EXPECT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType)); + startType = StartPipType::NULL_START; + pipControl->pipOption_->SetContentSize(10, 10); + EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType)); + pipControl->pipOption_->SetContentSize(0, 10); + EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType)); + pipControl->pipOption_->SetContentSize(10, 0); + EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType)); + pipControl->pipOption_->SetContentSize(0, 0); + EXPECT_CALL(*(mw), Show(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->ShowPictureInPictureWindow(startType)); +} + +/** + * @tc.name: StopPictureInPicture + * @tc.desc: StopPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPicture, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->curState_ = PiPWindowState::STATE_STOPPING; + pipControl->isStoppedFromClient_ = false; + EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP)); +} + +/** + * @tc.name: StopPictureInPicture + * @tc.desc: StopPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPicture001, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->curState_ = PiPWindowState::STATE_STOPPED; + pipControl->isStoppedFromClient_ = false; + EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP)); +} + +/** + * @tc.name: StopPictureInPicture + * @tc.desc: StopPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPicture002, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->curState_ = PiPWindowState::STATE_UNDEFINED; + pipControl->isStoppedFromClient_ = false; + EXPECT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->StopPictureInPicture(false, StopPipType::NULL_STOP)); +} + +/** + * @tc.name: StopPictureInPictureWindowNull + * @tc.desc: StopPictureInPictureWindowNull + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPictureWindowNull, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->curState_ = PiPWindowState::STATE_STOPPING; + pipControl->isStoppedFromClient_ = true; + pipControl->window_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP)); +} + +/** + * @tc.name: StopPictureInPictureWindowNotNull + * @tc.desc: StopPictureInPictureWindowNotNull + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPictureWindowNotNull, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->window_ = mw; + pipControl->isStoppedFromClient_ = true; + pipControl->curState_ = PiPWindowState::STATE_STOPPING; + EXPECT_EQ(WMError::WM_OK, pipControl->StopPictureInPicture(false, StopPipType::NULL_STOP)); +} + +/** + * @tc.name: StopPictureInPictureWindowNotNull + * @tc.desc: StopPictureInPictureWindowNotNull + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPictureWindowNotNull001, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->window_ = mw; + pipControl->isStoppedFromClient_ = true; + pipControl->curState_ = PiPWindowState::STATE_STARTED; + EXPECT_EQ(PiPWindowState::STATE_STARTED, pipControl->GetControllerState()); + EXPECT_EQ(WMError::WM_OK, pipControl->StopPictureInPicture(true, StopPipType::NULL_STOP)); + EXPECT_NE(PiPWindowState::STATE_STARTED, pipControl->GetControllerState()); +} + +/** + * @tc.name: CreatePictureInPictureWindowOptionNull + * @tc.desc: CreatePictureInPictureWindowOptionNull + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindowOptionNull, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_ = nullptr; + StartPipType startType = StartPipType::AUTO_START; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); +} + +/** + * @tc.name: CreatePictureInPictureWindowOptionNotNull + * @tc.desc: CreatePictureInPictureWindowOptionNotNull + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindowOptionNotNull, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + StartPipType startType = StartPipType::AUTO_START; + option->SetContext(nullptr); + ASSERT_EQ(nullptr, option->GetContext()); + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); +} + +/** + * @tc.name: CreatePictureInPictureWindowContextNotNull + * @tc.desc: CreatePictureInPictureWindowContextNotNull + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindowContextNotNull, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + StartPipType startType = StartPipType::AUTO_START; + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + pipControl->mainWindow_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); + delete contextPtr; + +} + +/** + * @tc.name: CreatePictureInPictureWindowPipOptionNull + * @tc.desc: CreatePictureInPictureWindowPipOptionNull + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindowPipOptionNull, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_ = nullptr; + StartPipType startType = StartPipType::AUTO_START; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); +} + +/** + * @tc.name: CreatePictureInPictureWindowMainWindowNull + * @tc.desc: CreatePictureInPictureWindowMainWindowNull + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindowMainWindowNull, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_ = nullptr; + StartPipType startType = StartPipType::AUTO_START; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); +} + +/** + * @tc.name: CreatePictureInPictureWindow + * @tc.desc: CreatePictureInPictureWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindow001, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_ = option; + StartPipType startType = StartPipType::AUTO_START; + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + pipControl->pipOption_->SetXComponentController(nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->mainWindow_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); + delete contextPtr; +} + +/** + * @tc.name: CreatePictureInPictureWindow + * @tc.desc: CreatePictureInPictureWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindow002, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_ = option; + StartPipType startType = StartPipType::AUTO_START; + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + pipControl->pipOption_->SetXComponentController(xComponentController); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->mainWindow_ = nullptr; + ASSERT_EQ(pipControl->pipOption_->GetXComponentController(), xComponentController); + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); + delete contextPtr; +} + +/** + * @tc.name: CreatePictureInPictureWindow + * @tc.desc: CreatePictureInPictureWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindow003, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_ = option; + StartPipType startType = StartPipType::AUTO_START; + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + pipControl->pipOption_->SetXComponentController(nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->mainWindow_ = mw; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); + delete contextPtr; +} + +/** + * @tc.name: CreatePictureInPictureWindow + * @tc.desc: CreatePictureInPictureWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, CreatePictureInPictureWindow004, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_ = option; + option->SetDefaultWindowSizeType(1); + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + std::shared_ptr xComponentController = std::make_shared(); + pipControl->pipOption_->SetXComponentController(xComponentController); + ASSERT_EQ(pipControl->pipOption_->GetXComponentController(), xComponentController); + pipControl->pipOption_->SetTypeNodeEnabled(true); + pipControl->mainWindow_ = mw; + StartPipType startType = StartPipType::NULL_START; + EXPECT_CALL(*(mw), GetWindowState()).Times(2).WillOnce(Return(WindowState::STATE_CREATED)); + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->CreatePictureInPictureWindow(startType)); + EXPECT_EQ(1, option->GetDefaultWindowSizeType()); + startType = StartPipType::AUTO_START; + delete contextPtr; +} + +/** + * @tc.name: StartPictureInPicture + * @tc.desc: StartPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StartPictureInPicture001, TestSize.Level1) +{ + StartPipType startType = StartPipType::AUTO_START; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType)); +} + +/** + * @tc.name: StartPictureInPicture + * @tc.desc: StartPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StartPictureInPicture002, TestSize.Level1) +{ + StartPipType startType = StartPipType::AUTO_START; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + option->SetContext(nullptr); + ASSERT_EQ(nullptr, option->GetContext()); + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType)); +} + +/** + * @tc.name: StartPictureInPicture + * @tc.desc: StartPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StartPictureInPicture003, TestSize.Level1) +{ + StartPipType startType = StartPipType::AUTO_START; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + pipControl->curState_ = PiPWindowState::STATE_STARTING; + EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StartPictureInPicture(startType)); + delete contextPtr; +} + +/** + * @tc.name: StartPictureInPicture + * @tc.desc: StartPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StartPictureInPicture004, TestSize.Level1) +{ + StartPipType startType = StartPipType::AUTO_START; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + pipControl->curState_ = PiPWindowState::STATE_STARTED; + EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StartPictureInPicture(startType)); + delete contextPtr; +} + +/** + * @tc.name: StartPictureInPicture + * @tc.desc: StartPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StartPictureInPicture005, TestSize.Level1) +{ + StartPipType startType = StartPipType::AUTO_START; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_ = option; + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + pipControl->curState_ = PiPWindowState::STATE_UNDEFINED; + + pipControl->pipOption_->SetNavigationId("navId"); + pipControl->mainWindow_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType)); + delete contextPtr; +} + +/** + * @tc.name: StartPictureInPicture + * @tc.desc: StartPictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StartPictureInPicture006, TestSize.Level1) +{ + StartPipType startType = StartPipType::AUTO_START; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_ = option; + AbilityRuntime::AbilityContextImpl* contextPtr = new AbilityRuntime::AbilityContextImpl(); + option->SetContext(contextPtr); + pipControl->curState_ = PiPWindowState::STATE_UNDEFINED; + + pipControl->mainWindow_ = nullptr; + pipControl->pipOption_->SetNavigationId(""); + auto pipControl1 = sptr::MakeSptr(option, mw, 100, nullptr); + auto pipControl2 = sptr::MakeSptr(option, mw, 200, nullptr); + PictureInPictureManager::SetActiveController(pipControl1); + PictureInPictureManager::IsActiveController(pipControl2); + pipControl->mainWindowId_ = 100; + PictureInPictureManager::IsAttachedToSameWindow(100); + pipControl->window_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType)); + pipControl->window_ = mw; + pipControl->pipOption_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_CREATE_FAILED, pipControl->StartPictureInPicture(startType)); + pipControl->pipOption_ = option; + PictureInPictureManager::RemoveActiveController(pipControl1); + PictureInPictureManager::IsActiveController(pipControl); + pipControl->StartPictureInPicture(startType); + delete contextPtr; +} + +/** + * @tc.name: StartPictureInPictureInner + * @tc.desc: StartPictureInPictureInner + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StartPictureInPictureInner, TestSize.Level1) +{ + StartPipType startType = StartPipType::USER_START; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(true); + EXPECT_NE(WMError::WM_OK, pipControl->StartPictureInPictureInner(startType)); +} + +/** + * @tc.name: StopPictureInPictureFromClient + * @tc.desc: StopPictureInPictureFromClient + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPictureFromClient, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr mw1 = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw1); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->window_ = mw1; + EXPECT_NE(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->StopPictureInPictureFromClient()); + pipControl->window_ = nullptr; + EXPECT_NE(WMError::WM_OK, pipControl->StopPictureInPictureFromClient()); + pipControl->window_ = mw1; + pipControl->curState_ = PiPWindowState::STATE_STOPPING; + EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPictureFromClient()); + pipControl->curState_ = PiPWindowState::STATE_STOPPED; + EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPictureFromClient()); + pipControl->curState_ = PiPWindowState::STATE_RESTORING; + EXPECT_EQ(WMError::WM_ERROR_PIP_REPEAT_OPERATION, pipControl->StopPictureInPictureFromClient()); + pipControl->curState_ = PiPWindowState::STATE_UNDEFINED; + EXPECT_CALL(*(mw1), NotifyPrepareClosePiPWindow()).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING)); + EXPECT_EQ(WMError::WM_ERROR_PIP_DESTROY_FAILED, pipControl->StopPictureInPictureFromClient()); + EXPECT_CALL(*(mw1), NotifyPrepareClosePiPWindow()).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->StopPictureInPictureFromClient()); +} + +/** + * @tc.name: GetPipWindow + * @tc.desc: GetPipWindow/SetPipWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, GetPipWindow, TestSize.Level1) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr window_; + sptr window; + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + + pipControl->SetPipWindow(window); + auto ret = pipControl->GetPipWindow(); + ASSERT_EQ(pipControl->window_, ret); +} + +/** + * @tc.name: SetAutoStartEnabled + * @tc.desc: SetAutoStartEnabled + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, SetAutoStartEnabled, TestSize.Level1) +{ + bool enable = true; + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + pipControl->mainWindow_ = nullptr; + pipControl->SetAutoStartEnabled(enable); + pipControl->mainWindow_ = mw; + pipControl->pipOption_ = nullptr; + pipControl->SetAutoStartEnabled(enable); + pipControl->pipOption_ = option; + + pipControl->isAutoStartEnabled_ = enable; + EXPECT_EQ(true, pipControl->isAutoStartEnabled_); + pipControl->pipOption_->SetTypeNodeEnabled(true); + EXPECT_EQ(true, pipControl->IsTypeNodeEnabled()); + EXPECT_CALL(*(mw), SetAutoStartPiP(_, _, _, _)).WillRepeatedly(Return()); + pipControl->SetAutoStartEnabled(enable); + enable = false; + pipControl->isAutoStartEnabled_ = enable; + EXPECT_EQ(false, pipControl->isAutoStartEnabled_); + pipControl->pipOption_->SetTypeNodeEnabled(true); + EXPECT_EQ(true, pipControl->IsTypeNodeEnabled()); + EXPECT_CALL(*(mw), SetAutoStartPiP(_, _, _, _)).WillRepeatedly(Return()); + pipControl->SetAutoStartEnabled(enable); + pipControl->pipOption_->SetTypeNodeEnabled(false); + EXPECT_EQ(false, pipControl->IsTypeNodeEnabled()); + EXPECT_CALL(*(mw), SetAutoStartPiP(_, _, _, _)).WillRepeatedly(Return()); + pipControl->SetAutoStartEnabled(enable); + pipControl->pipOption_->SetNavigationId(""); + EXPECT_EQ("", pipControl->pipOption_->GetNavigationId()); + pipControl->SetAutoStartEnabled(enable); +} + +/** + * @tc.name: IsAutoStartEnabled + * @tc.desc: IsAutoStartEnabled + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, IsAutoStartEnabled, TestSize.Level1) +{ + bool enable = true; + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + + pipControl->IsAutoStartEnabled(enable); + auto ret = pipControl->GetControllerState(); + ASSERT_EQ(PiPWindowState::STATE_UNDEFINED, ret); +} + +/** + * @tc.name: UpdateContentSize01 + * @tc.desc: UpdateContentSize + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UpdateContentSize01, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + + int32_t width = 0; + int32_t height = 0; + pipControl->UpdateContentSize(width, height); + height = 150; + pipControl->UpdateContentSize(width, height); + height = 0; + width = 100; + pipControl->UpdateContentSize(width, height); + height = 150; + pipControl->UpdateContentSize(width, height); + + pipControl->curState_ = PiPWindowState::STATE_UNDEFINED; + pipControl->UpdateContentSize(width, height); + pipControl->curState_ = PiPWindowState::STATE_STARTED; + pipControl->UpdateContentSize(width, height); +} + +/** + * @tc.name: UpdateContentSize02 + * @tc.desc: UpdateContentSize + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UpdateContentSize02, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->curState_ = PiPWindowState::STATE_STARTED; + pipControl->window_ = nullptr; + int32_t width = 10; + int32_t height = 20; + pipControl->UpdateContentSize(width, height); + pipControl->window_ = mw; + + pipControl->pipOption_->SetTypeNodeEnabled(true); + EXPECT_EQ(true, pipControl->IsTypeNodeEnabled()); + pipControl->mainWindowXComponentController_ = xComponentController; + pipControl->UpdateContentSize(width, height); + pipControl->pipOption_->SetTypeNodeEnabled(false); + EXPECT_EQ(false, pipControl->IsTypeNodeEnabled()); + pipControl->windowRect_ = { 0, 0, 0, 0 }; + EXPECT_EQ(false, pipControl->IsContentSizeChanged(0, 0, 0, 0)); + pipControl->UpdateContentSize(width, height); + pipControl->IsContentSizeChanged(10, 10, 10, 10); + EXPECT_NE(true, pipControl->IsContentSizeChanged(0, 0, 0, 0)); + pipControl->UpdateContentSize(width, height); + pipControl->mainWindowXComponentController_ = nullptr; + pipControl->UpdateContentSize(width, height); +} + +/** + * @tc.name: UpdatePiPControlStatus + * @tc.desc: UpdatePiPControlStatus + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UpdatePiPControlStatus001, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + auto controlType = PiPControlType::VIDEO_PLAY_PAUSE; + auto status = PiPControlStatus::ENABLED; + pipControl->UpdatePiPControlStatus(controlType, status); + EXPECT_EQ(1, pipControl->pipOption_->GetControlEnable().size()); +} + +/** + * @tc.name: UpdatePiPControlStatus + * @tc.desc: UpdatePiPControlStatus + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UpdatePiPControlStatus002, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + auto controlType = PiPControlType::VIDEO_PLAY_PAUSE; + auto status = PiPControlStatus::PLAY; + pipControl->UpdatePiPControlStatus(controlType, status); + EXPECT_EQ(1, pipControl->pipOption_->GetControlStatus().size()); + pipControl->window_ = nullptr; + pipControl->UpdatePiPControlStatus(controlType, status); + pipControl->window_ = mw; + pipControl->UpdatePiPControlStatus(controlType, status); +} + +/** + * @tc.name: IsContentSizeChanged + * @tc.desc: IsContentSizeChanged + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, IsContentSizeChanged, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = + new (std::nothrow) PictureInPictureController(option, mw, 100, nullptr); + pipControl->windowRect_ = { 0, 0, 0, 0 }; + EXPECT_EQ(true, pipControl->IsContentSizeChanged(10.5, 0, 0, 0)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(0, 10.5, 0, 0)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(0, 0, 10.5, 0)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(0, 0, 0, 10.5)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(10.5, 10.5, 0, 0)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(10.5, 0, 10.5, 0)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(10.5, 0, 0, 10.5)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(0, 10.5, 10.5, 0)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(0, 10.5, 0, 10.5)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(0, 0, 10.5, 10.5)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(10.5, 10.5, 10.5, 0)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(10.5, 10.5, 0, 10.5)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(10.5, 0, 10.5, 10.5)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(0, 10.5, 10.5, 10.5)); + EXPECT_EQ(true, pipControl->IsContentSizeChanged(10.5, 10.5, 10.5, 10.5)); + EXPECT_EQ(false, pipControl->IsContentSizeChanged(0, 0, 0, 0)); +} + +/** + * @tc.name: DoActionEvent + * @tc.desc: DoActionEvent + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, DoActionEvent001, TestSize.Level1) +{ + std::string actionName = ""; + int32_t status = 0; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + sptr listener = nullptr; + + pipControl->DoActionEvent(actionName, status); + EXPECT_EQ(0, pipControl->pipOption_->GetControlStatus().size()); +} + +/** + * @tc.name: DoActionEvent + * @tc.desc: DoActionEvent + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, DoActionEvent002, TestSize.Level1) +{ + std::string actionName = "nextVideo"; + int32_t status = 0; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + sptr listener = nullptr; + + pipControl->DoActionEvent(actionName, status); + EXPECT_EQ(1, pipControl->pipOption_->GetControlStatus().size()); +} + +/** + * @tc.name: DoControlEvent + * @tc.desc: DoControlEvent + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, DoControlEvent, TestSize.Level1) +{ + auto controlType = PiPControlType::VIDEO_PLAY_PAUSE; + auto status = PiPControlStatus::PLAY; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + sptr listener = nullptr; + + pipControl->pipOption_ = nullptr; + pipControl->DoControlEvent(controlType, status); + pipControl->pipOption_ = option; + pipControl->DoControlEvent(controlType, status); + pipControl->RegisterPiPControlObserver(listener); + pipControl->DoControlEvent(controlType, status); + EXPECT_EQ(1, pipControl->pipOption_->GetControlStatus().size()); +} + +/** + * @tc.name: PreRestorePictureInPicture + * @tc.desc: PreRestorePictureInPicture + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, PreRestorePictureInPicture, TestSize.Level1) +{ + sptr listener = nullptr; + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->curState_ = PiPWindowState::STATE_STARTED; + auto res = pipControl->RegisterPiPLifecycle(listener); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res); + pipControl->PreRestorePictureInPicture(); + EXPECT_EQ(PiPWindowState::STATE_RESTORING, pipControl->curState_); +} + +/** + * @tc.name: RestorePictureInPictureWindow + * @tc.desc: RestorePictureInPictureWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, RestorePictureInPictureWindow, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->curState_ = PiPWindowState::STATE_STARTED; + pipControl->window_ = mw; + pipControl->RestorePictureInPictureWindow(); + EXPECT_EQ(PiPWindowState::STATE_STOPPING, pipControl->curState_); +} + +/** + * @tc.name: UpdateWinRectByComponent + * @tc.desc: UpdateWinRectByComponent + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UpdateWinRectByComponent001, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_->SetTypeNodeEnabled(true); + pipControl->UpdateWinRectByComponent(); + EXPECT_EQ(pipControl->windowRect_.width_, 16); + EXPECT_EQ(pipControl->windowRect_.height_, 9); +} + +/** + * @tc.name: UpdateWinRectByComponent + * @tc.desc: UpdateWinRectByComponent + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UpdateWinRectByComponent002, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->mainWindowXComponentController_ = nullptr; + pipControl->UpdateWinRectByComponent(); + pipControl->mainWindowXComponentController_ = xComponentController; + + pipControl->windowRect_.width_ = 0; + pipControl->windowRect_.height_ = 10; + pipControl->UpdateWinRectByComponent(); + EXPECT_EQ(pipControl->windowRect_.height_, 0); + pipControl->windowRect_.width_ = 10; + pipControl->windowRect_.height_ = 0; + pipControl->UpdateWinRectByComponent(); + pipControl->windowRect_.width_ = 0; + pipControl->UpdateWinRectByComponent(); + pipControl->windowRect_.width_ = 10; + pipControl->windowRect_.height_ = 10; + pipControl->UpdateWinRectByComponent(); + EXPECT_EQ(pipControl->windowRect_.posX_, 0); + EXPECT_EQ(pipControl->windowRect_.posY_, 0); +} + +/** + * @tc.name: RegisterPiPLifecycle + * @tc.desc: RegisterPiPLifecycle/UnregisterPiPLifecycle + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, RegisterListener, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + auto listener = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener); + auto listener1 = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener1); + pipControl->pipLifeCycleListeners_.push_back(listener); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->RegisterPiPLifecycle(nullptr)); + EXPECT_EQ(WMError::WM_OK, pipControl->RegisterPiPLifecycle(listener)); + EXPECT_EQ(WMError::WM_OK, pipControl->RegisterPiPLifecycle(listener1)); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->UnregisterPiPLifecycle(nullptr)); + EXPECT_EQ(WMError::WM_OK, pipControl->UnregisterPiPLifecycle(listener)); +} + +/** + * @tc.name: RegisterPiPActionObserver + * @tc.desc: RegisterPiPActionObserver/UnregisterPiPActionObserver + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, RegisterPiPActionObserver, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + auto listener = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener); + auto listener1 = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener1); + pipControl->pipActionObservers_.push_back(listener); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->RegisterPiPActionObserver(nullptr)); + EXPECT_EQ(WMError::WM_OK, pipControl->RegisterPiPActionObserver(listener)); + EXPECT_EQ(WMError::WM_OK, pipControl->RegisterPiPActionObserver(listener1)); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->UnregisterPiPActionObserver(nullptr)); + EXPECT_EQ(WMError::WM_OK, pipControl->UnregisterPiPActionObserver(listener)); +} + +/** + * @tc.name: RegisterPiPControlObserver + * @tc.desc: RegisterPiPControlObserver/UnregisterPiPControlObserver + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, RegisterPiPControlObserver, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + auto listener = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener); + auto listener1 = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener1); + pipControl->pipControlObservers_.push_back(listener); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->RegisterPiPControlObserver(nullptr)); + EXPECT_EQ(WMError::WM_OK, pipControl->RegisterPiPControlObserver(listener)); + EXPECT_EQ(WMError::WM_OK, pipControl->RegisterPiPControlObserver(listener1)); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->UnregisterPiPControlObserver(nullptr)); + EXPECT_EQ(WMError::WM_OK, pipControl->UnregisterPiPControlObserver(listener)); +} + +/** + * @tc.name: IsPullPiPAndHandleNavigation + * @tc.desc: IsPullPiPAndHandleNavigation + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, IsPullPiPAndHandleNavigation001, TestSize.Level1) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(true); + EXPECT_EQ(true, pipControl->IsPullPiPAndHandleNavigation()); +} + +/** + * @tc.name: IsPullPiPAndHandleNavigation + * @tc.desc: IsPullPiPAndHandleNavigation + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, IsPullPiPAndHandleNavigation002, TestSize.Level1) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->pipOption_->SetNavigationId(""); + EXPECT_EQ(true, pipControl->IsPullPiPAndHandleNavigation()); +} + +/** + * @tc.name: IsPullPiPAndHandleNavigation + * @tc.desc: IsPullPiPAndHandleNavigation + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, IsPullPiPAndHandleNavigation003, TestSize.Level1) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->pipOption_->SetNavigationId("navId"); + pipControl->mainWindow_ = nullptr; + EXPECT_EQ(false, pipControl->IsPullPiPAndHandleNavigation()); + pipControl->mainWindow_ = mw; +} + +/** + * @tc.name: ResetExtController + * @tc.desc: ResetExtController + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, ResetExtController, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + std::shared_ptr xComponentController1 = std::make_shared(); + ASSERT_NE(nullptr, xComponentController1); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_->SetTypeNodeEnabled(true); + pipControl->ResetExtController(); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->ResetExtController(); + + pipControl->pipXComponentController_ = nullptr; + pipControl->mainWindowXComponentController_ = nullptr; + pipControl->ResetExtController(); + pipControl->mainWindowXComponentController_ = nullptr; + pipControl->pipXComponentController_ = xComponentController; + pipControl->ResetExtController(); + pipControl->pipXComponentController_ = nullptr; + pipControl->mainWindowXComponentController_ = xComponentController1; + pipControl->ResetExtController(); + pipControl->pipXComponentController_ = xComponentController; + EXPECT_CALL(*(xComponentController1), ResetExtController(_)) + .Times(1) + .WillOnce(Return(XComponentControllerErrorCode::XCOMPONENT_CONTROLLER_TYPE_ERROR)); + pipControl->ResetExtController(); + EXPECT_CALL(*(xComponentController1), ResetExtController(_)) + .Times(1) + .WillOnce(Return(XComponentControllerErrorCode::XCOMPONENT_CONTROLLER_NO_ERROR)); + pipControl->ResetExtController(); +} + +/** + * @tc.name: OnPictureInPictureStart + * @tc.desc: OnPictureInPictureStart + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, OnPictureInPictureStart, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->OnPictureInPictureStart(); +} + +/** + * @tc.name: IsTypeNodeEnabled + * @tc.desc: IsTypeNodeEnabled + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, IsTypeNodeEnabled001, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(true); + EXPECT_TRUE(pipControl->IsTypeNodeEnabled()); +} + +/** + * @tc.name: IsTypeNodeEnabled + * @tc.desc: IsTypeNodeEnabled + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, IsTypeNodeEnabled002, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(false); + EXPECT_TRUE(!pipControl->IsTypeNodeEnabled()); +} + +/** + * @tc.name: IsTypeNodeEnabled + * @tc.desc: IsTypeNodeEnabled + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, IsTypeNodeEnabled003, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_ = nullptr; + EXPECT_TRUE(!pipControl->IsTypeNodeEnabled()); +} + +/** + * @tc.name: GetTypeNode + * @tc.desc: GetTypeNode + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, GetTypeNode, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + pipControl->pipOption_->SetTypeNodeRef(nullptr); + ASSERT_EQ(nullptr, pipControl->GetTypeNode()); + pipControl->pipOption_ = nullptr; + ASSERT_EQ(nullptr, pipControl->GetTypeNode()); +} + +/** + * @tc.name: SetXComponentController + * @tc.desc: SetXComponentController + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, SetXComponentController, TestSize.Level1) +{ + sptr listener = nullptr; + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + std::shared_ptr xComponentController1 = std::make_shared(); + ASSERT_NE(nullptr, xComponentController1); + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + pipControl->pipOption_->SetTypeNodeEnabled(true); + EXPECT_EQ(WMError::WM_OK, pipControl->SetXComponentController(xComponentController)); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->window_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->SetXComponentController(xComponentController)); + pipControl->window_ = mw; + + pipControl->pipXComponentController_ = nullptr; + pipControl->mainWindowXComponentController_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->SetXComponentController(xComponentController)); + pipControl->mainWindowXComponentController_ = nullptr; + pipControl->pipXComponentController_ = xComponentController; + EXPECT_EQ(WMError::WM_ERROR_PIP_STATE_ABNORMALLY, pipControl->SetXComponentController(xComponentController)); + pipControl->mainWindowXComponentController_ = xComponentController1; + EXPECT_CALL(*(xComponentController1), SetExtController(_)) + .Times(1) + .WillOnce(Return(XComponentControllerErrorCode::XCOMPONENT_CONTROLLER_TYPE_ERROR)); + EXPECT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, pipControl->SetXComponentController(xComponentController)); + EXPECT_CALL(*(xComponentController1), SetExtController(_)) + .Times(1) + .WillOnce(Return(XComponentControllerErrorCode::XCOMPONENT_CONTROLLER_NO_ERROR)); + EXPECT_EQ(WMError::WM_OK, pipControl->SetXComponentController(xComponentController)); +} + +/** + * @tc.name: RegisterPiPTypeNodeChange + * @tc.desc: RegisterPiPTypeNodeChange + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, RegisterPiPTypeNodeChange001, Function | SmallTest | Level2) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->RegisterPiPTypeNodeChange(nullptr)); +} + +/** + * @tc.name: RegisterPiPTypeNodeChange + * @tc.desc: RegisterPiPTypeNodeChange + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, RegisterPiPTypeNodeChange002, Function | SmallTest | Level2) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + auto listener = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener); + EXPECT_EQ(WMError::WM_OK, pipControl->RegisterPiPTypeNodeChange(listener)); +} + +/** + * @tc.name: UnRegisterPiPTypeNodeChange + * @tc.desc: UnRegisterPiPTypeNodeChange + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UnRegisterPiPTypeNodeChange001, Function | SmallTest | Level2) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + EXPECT_EQ(WMError::WM_ERROR_NULLPTR, pipControl->UnRegisterPiPTypeNodeChange(nullptr)); +} + +/** + * @tc.name: UnRegisterPiPTypeNodeChange + * @tc.desc: UnRegisterPiPTypeNodeChange + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UnRegisterPiPTypeNodeChange002, Function | SmallTest | Level2) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + auto listener = sptr::MakeSptr(); + ASSERT_NE(nullptr, listener); + EXPECT_EQ(WMError::WM_OK, pipControl->UnRegisterPiPTypeNodeChange(listener)); +} + +/** + * @tc.name: UpdateContentNodeRef + * @tc.desc: UpdateContentNodeRef + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UpdateContentNodeRef, TestSize.Level1) +{ + sptr mw = new MockNewWindow(); + sptr option = new PipOption(); + sptr pipControl = new PictureInPictureController(option, mw, 100, nullptr); + pipControl->pipOption_ = nullptr; + EXPECT_EQ(false, pipControl->IsTypeNodeEnabled()); + napi_ref nodeRef = nullptr; + pipControl->UpdateContentNodeRef(nodeRef); + pipControl->pipOption_ = option; + pipControl->pipOption_->SetTypeNodeEnabled(true); + EXPECT_EQ(true, pipControl->IsTypeNodeEnabled()); + pipControl->UpdateContentNodeRef(nodeRef); + pipControl->pipOption_->SetTypeNodeEnabled(false); + EXPECT_EQ(false, pipControl->IsTypeNodeEnabled()); + pipControl->UpdateContentNodeRef(nodeRef); + pipControl->isAutoStartEnabled_ = true; + pipControl->UpdateContentNodeRef(nodeRef); + pipControl->isAutoStartEnabled_ = false; + EXPECT_EQ(true, pipControl->IsTypeNodeEnabled()); +} + +/** + * @tc.name: UpdatePiPSourceRect + * @tc.desc: UpdatePiPSourceRect + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, UpdatePiPSourceRect, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + std::shared_ptr xComponentController = std::make_shared(); + ASSERT_NE(nullptr, xComponentController); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_->SetTypeNodeEnabled(true); + pipControl->window_ = mw; + pipControl->UpdatePiPSourceRect(); + EXPECT_EQ(0, pipControl->windowRect_.posX_); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->UpdatePiPSourceRect(); + + pipControl->mainWindowXComponentController_ = nullptr; + pipControl->window_ = mw; + pipControl->UpdatePiPSourceRect(); + pipControl->mainWindowXComponentController_ = xComponentController; + pipControl->window_ = nullptr; + pipControl->UpdatePiPSourceRect(); + pipControl->mainWindowXComponentController_ = nullptr; + pipControl->UpdatePiPSourceRect(); + pipControl->mainWindowXComponentController_ = xComponentController; + pipControl->window_ = mw; + pipControl->UpdatePiPSourceRect(); + EXPECT_EQ(0, pipControl->windowRect_.posX_); + EXPECT_EQ(0, pipControl->windowRect_.posY_); + EXPECT_EQ(0, pipControl->windowRect_.width_); + EXPECT_EQ(0, pipControl->windowRect_.height_); +} + +/** + * @tc.name: DestroyPictureInPictureWindow + * @tc.desc: DestroyPictureInPictureWindow + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, DestroyPictureInPictureWindow, TestSize.Level1) +{ + sptr mw = new (std::nothrow) MockNewWindow(); + ASSERT_NE(nullptr, mw); + sptr option = new (std::nothrow) PipOption(); + ASSERT_NE(nullptr, option); + sptr pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->window_ = nullptr; + ASSERT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, pipControl->DestroyPictureInPictureWindow()); + + sptr window = sptr::MakeSptr(); + pipControl->window_ = window; + EXPECT_CALL(*(window), Destroy(0)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING)); + EXPECT_EQ(WMError::WM_ERROR_PIP_DESTROY_FAILED, pipControl->DestroyPictureInPictureWindow()); + + EXPECT_CALL(*(window), Destroy(0)).Times(1).WillOnce(Return(WMError::WM_OK)); + pipControl->pipOption_ = nullptr; + pipControl->mainWindow_ = nullptr; + pipControl->window_ = window; + EXPECT_EQ(WMError::WM_OK, pipControl->DestroyPictureInPictureWindow()); + pipControl->mainWindow_ = mw; + pipControl->window_ = window; + EXPECT_CALL(*(window), Destroy(0)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->DestroyPictureInPictureWindow()); + pipControl->pipOption_ = option; + pipControl->pipOption_->SetNavigationId("navId"); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->mainWindow_ = nullptr; + pipControl->window_ = window; + EXPECT_CALL(*(window), Destroy(0)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->DestroyPictureInPictureWindow()); + pipControl->pipOption_->SetNavigationId(""); + pipControl->mainWindow_ = mw; + pipControl->window_ = window; + EXPECT_CALL(*(window), Destroy(0)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, pipControl->DestroyPictureInPictureWindow()); +} + +/** + * @tc.name: PrepareSource + * @tc.desc: PrepareSource + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, PrepareSource, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + ASSERT_NE(nullptr, pipControl); + pipControl->pipOption_->SetTypeNodeEnabled(true); + pipControl->PrepareSource(); + pipControl->pipOption_->SetTypeNodeEnabled(false); + pipControl->mainWindow_ = nullptr; + pipControl->PrepareSource(); + pipControl->mainWindow_ = mw; + pipControl->pipOption_->SetNavigationId(""); + pipControl->PrepareSource(); +} + +/** + * @tc.name: LocateSource + * @tc.desc: LocateSource + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, LocateSource, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + ASSERT_NE(nullptr, pipControl); + pipControl->window_ = nullptr; + pipControl->LocateSource(); + + pipControl->window_ = mw; + pipControl->LocateSource(); +} + +/** + * @tc.name: StopPictureInPictureInner + * @tc.desc: StopPictureInPictureInner + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPictureInner001, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, true)); +} + +/** + * @tc.name: StopPictureInPictureInner + * @tc.desc: StopPictureInPictureInner + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPictureInner002, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->window_ = nullptr; + EXPECT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, + pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, true)); +} + +/** + * @tc.name: StopPictureInPictureInner + * @tc.desc: StopPictureInPictureInner + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPictureInner003, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_ = option; + pipControl->window_ = nullptr; + pipControl->mainWindow_ = mw; + EXPECT_EQ(WMError::WM_ERROR_PIP_INTERNAL_ERROR, + pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, true)); +} + +/** + * @tc.name: StopPictureInPictureInner + * @tc.desc: StopPictureInPictureInner + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, StopPictureInPictureInner004, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + pipControl->pipOption_ = option; + pipControl->mainWindow_ = mw; + auto window = sptr::MakeSptr(); + pipControl->window_ = window; + EXPECT_EQ(WMError::WM_OK, pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, true)); + EXPECT_EQ(WMError::WM_OK, pipControl->StopPictureInPictureInner(StopPipType::NULL_STOP, false)); +} + +/** + * @tc.name: GetPipPossible + * @tc.desc: GetPipPossible + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, GetPipPossible, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + + const std::string multiWindowUIType = system::GetParameter("const.window.multiWindowUIType", ""); + bool isDeviceSupported = multiWindowUIType == "HandsetSmartWindow" || multiWindowUIType == "FreeFormMultiWindow" || + multiWindowUIType == "TabletSmartWindow"; + + bool pipSupported = false; + pipControl->pipOption_ = option; + pipControl->GetPipPossible(pipSupported); + EXPECT_EQ(isDeviceSupported, pipSupported); +} + +/** + * @tc.name: GetPipEnabled + * @tc.desc: GetPipEnabled + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, GetPipEnabled, TestSize.Level1) +{ + const std::string multiWindowUIType = system::GetParameter("const.window.multiWindowUIType", ""); + bool isDeviceSupported = multiWindowUIType == "HandsetSmartWindow" || multiWindowUIType == "FreeFormMultiWindow" || + multiWindowUIType == "TabletSmartWindow"; + bool pipSupported = PictureInPictureControllerBase::GetPipEnabled(); + EXPECT_EQ(isDeviceSupported, pipSupported); +} + +/** + * @tc.name: GetPipSettingSwitchStatusEnabled + * @tc.desc: GetPipSettingSwitchStatusEnabled + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, GetPipSettingSwitchStatusEnabled, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto option = sptr::MakeSptr(); + ASSERT_NE(nullptr, option); + auto pipControl = sptr::MakeSptr(option, mw, 100, nullptr); + const std::string multiWindowUIType = system::GetParameter("const.window.multiWindowUIType", ""); + bool isDeviceSupported = multiWindowUIType == "HandsetSmartWindow" || multiWindowUIType == "TabletSmartWindow"; + EXPECT_EQ(isDeviceSupported, pipControl->GetPipSettingSwitchStatusEnabled()); +} + +/** + * @tc.name: GetPiPSettingSwitchStatus + * @tc.desc: GetPiPSettingSwitchStatus + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, GetPiPSettingSwitchStatus001, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto pipOption = sptr::MakeSptr(); + ASSERT_NE(nullptr, pipOption); + auto pipControl = sptr::MakeSptr(pipOption, mw, 1, nullptr); + EXPECT_EQ(false, pipControl->GetPiPSettingSwitchStatus()); +} + +/** + * @tc.name: GetPiPSettingSwitchStatus + * @tc.desc: GetPiPSettingSwitchStatus + * @tc.type: FUNC + */ +HWTEST_F(PictureInPictureControllerNewTest, GetPiPSettingSwitchStatus002, TestSize.Level1) +{ + auto mw = sptr::MakeSptr(); + ASSERT_NE(nullptr, mw); + auto pipOption = sptr::MakeSptr(); + ASSERT_NE(nullptr, pipOption); + auto pipControl = sptr::MakeSptr(pipOption, mw, 1, nullptr); + + sptr option = sptr::MakeSptr(); + option->SetWindowName("GetPiPSettingSwitchStatus"); + sptr window = sptr::MakeSptr(option); + window->property_->SetPersistentId(1); + window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + WindowSessionImpl::windowSessionMap_.clear(); + WindowSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(), + std::pair>(window->GetWindowId(), window))); + EXPECT_EQ(false, pipControl->GetPiPSettingSwitchStatus()); + WindowSessionImpl::windowSessionMap_.clear(); +} +} // namespace +} // namespace Rosen +} // namespace OHOS \ No newline at end of file -- Gitee