From 3b253bf1e9baa56906091edea8cc4193fe9c7593 Mon Sep 17 00:00:00 2001 From: shuangshuangliu Date: Tue, 26 Aug 2025 14:35:00 +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: I149198500203055bd6d8649e0549a314ce4a173d --- wm/test/unittest/BUILD.gn | 12 + wm/test/unittest/window_impl_new_test.cpp | 1513 +++++++++++++++++++++ 2 files changed, 1525 insertions(+) create mode 100644 wm/test/unittest/window_impl_new_test.cpp diff --git a/wm/test/unittest/BUILD.gn b/wm/test/unittest/BUILD.gn index 6a9fca35b8..86f710ff01 100644 --- a/wm/test/unittest/BUILD.gn +++ b/wm/test/unittest/BUILD.gn @@ -39,6 +39,7 @@ group("unittest") { ":wm_window_display_change_adapter_test", ":wm_window_effect_test", ":wm_window_impl_listener_test", + ":wm_window_impl_new_test", ":wm_window_impl_test", ":wm_window_impl_test2", ":wm_window_impl_test3", @@ -169,6 +170,17 @@ ohos_unittest("wm_window_impl_test") { external_deps += [ "common_event_service:cesfwk_innerkits" ] } +ohos_unittest("wm_window_impl_new_test") { + module_out_path = module_out_path + + sources = [ "window_impl_new_test.cpp" ] + + deps = [ ":wm_unittest_common" ] + + external_deps = test_external_deps + external_deps += [ "common_event_service:cesfwk_innerkits" ] +} + ohos_unittest("wm_window_impl_test2") { module_out_path = module_out_path diff --git a/wm/test/unittest/window_impl_new_test.cpp b/wm/test/unittest/window_impl_new_test.cpp new file mode 100644 index 0000000000..41464b6033 --- /dev/null +++ b/wm/test/unittest/window_impl_new_test.cpp @@ -0,0 +1,1513 @@ +/* + * Copyright (c) 2021-2022 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 "ability_context_impl.h" +#include "display_manager_proxy.h" +#include "mock_uicontent.h" +#include "mock_window_adapter.h" +#include "singleton_mocker.h" +#include "window_impl.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace Rosen { +using Mocker = SingletonMocker; + +class WindowImplNewTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; + void CreateStretchableWindow(sptr& window, const Rect& rect); + + static inline std::shared_ptr abilityContext_; + std::unique_ptr m = std::make_unique(); + +private: + static constexpr uint32_t WAIT_SYNC_IN_NS = 200000; +}; +void WindowImplNewTest::SetUpTestCase() {} + +void WindowImplNewTest::TearDownTestCase() {} + +void WindowImplNewTest::SetUp() {} + +void WindowImplNewTest::TearDown() +{ + usleep(WAIT_SYNC_IN_NS); +} + +void WindowImplNewTest::CreateStretchableWindow(sptr& window, const Rect& rect) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("StretchableWindowTest"); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowRect({ 1, 1, 1, 1 }); + window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + window->windowSystemConfig_.isStretchable_ = true; + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + ASSERT_EQ(WMError::WM_OK, window->Show()); + window->UpdateRect(rect, true, WindowSizeChangeReason::UNDEFINED); + ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect); +} + +namespace { +/** + * @tc.name: CreateWindow01 + * @tc.desc: Create window with no parentId + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, CreateWindow01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("CreateWindow01"); + sptr window = sptr::MakeSptr(option); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: CreateWindow02 + * @tc.desc: Create window with no parentId and no abilityContext + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, CreateWindow02, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("CreateWindow02"); + sptr window = sptr::MakeSptr(option); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR)); + EXPECT_EQ(WMError::WM_ERROR_SAMGR, window->Create(INVALID_WINDOW_ID)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: CreateWindow03 + * @tc.desc: Create window with illegal parentId + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, CreateWindow03, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("CreateWindow03"); + sptr window = sptr::MakeSptr(option); + EXPECT_EQ(WMError::WM_ERROR_INVALID_PARENT, window->Create(1234)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: CreateWindow04 + * @tc.desc: Create window with repeated windowName + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, CreateWindow04, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("CreateWindow04"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + + sptr option_other = sptr::MakeSptr(); + option_other->SetWindowName("CreateWindow04"); + sptr window_other = sptr::MakeSptr(option_other); + + EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, window_other->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); + EXPECT_EQ(WMError::WM_OK, window_other->Destroy()); +} + +/** + * @tc.name: CreateWindow05 + * @tc.desc: Create window with exist parentId + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, CreateWindow05, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("CreateWindow05_parent"); + sptr window = sptr::MakeSptr(option); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + sptr option2 = sptr::MakeSptr(); + option2->SetWindowName("CreateWindow05"); + sptr window2 = sptr::MakeSptr(option2); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window2->Create(window->GetWindowId())); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); + EXPECT_EQ(WMError::WM_OK, window2->Destroy()); +} + +/** + * @tc.name: CreateWindow06 + * @tc.desc: Create window with no default option, get and check Property + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, CreateWindow06, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("CreateWindow06"); + struct Rect rect = { 1, 2, 3u, 4u }; + option->SetWindowRect(rect); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + EXPECT_EQ(1, window->GetRequestRect().posX_); + EXPECT_EQ(2, window->GetRequestRect().posY_); + EXPECT_EQ(3u, window->GetRequestRect().width_); + EXPECT_EQ(4u, window->GetRequestRect().height_); + EXPECT_EQ(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, window->GetType()); + EXPECT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode()); + EXPECT_EQ("CreateWindow06", window->GetWindowName()); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: FindWindow01 + * @tc.desc: Find one exit window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, FindWindow01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("FindWindow01"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + ASSERT_NE(nullptr, WindowImpl::Find("FindWindow01")); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: FindWindow02 + * @tc.desc: Add another window, find both two windows + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, FindWindow02, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("FindWindow02"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + option->SetWindowName("FindWindow02_other"); + sptr window2 = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window2->Create(INVALID_WINDOW_ID)); + + ASSERT_NE(nullptr, WindowImpl::Find("FindWindow02_other")); + ASSERT_NE(nullptr, WindowImpl::Find("FindWindow02")); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window2->Destroy()); +} + +/** + * @tc.name: FindWindow03 + * @tc.desc: Find one no exit window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, FindWindow03, TestSize.Level1) +{ + ASSERT_EQ(nullptr, WindowImpl::Find("FindWindow03")); +} + +/** + * @tc.name: FindWindow04 + * @tc.desc: Find window with empty name + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, FindWindow04, TestSize.Level1) +{ + ASSERT_EQ(nullptr, WindowImpl::Find("")); +} + +/** + * @tc.name: FindWindow05 + * @tc.desc: Find one destroyed window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, FindWindow05, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("FindWindow05"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); + ASSERT_EQ(nullptr, WindowImpl::Find("FindWindow05")); +} + +/** + * @tc.name: RequestVsyncSucc + * @tc.desc: RequestVsync Test Succ + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, RequestVsyncSucc, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("RequestVsyncSucc"); + sptr window = sptr::MakeSptr(option); + std::shared_ptr vsyncCallback = std::make_shared(); + window->SetWindowState(WindowState::STATE_DESTROYED); + EXPECT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState()); + window->RequestVsync(vsyncCallback); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: RequestVsyncErr + * @tc.desc: RequestVsync Test Err + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, RequestVsyncErr, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("RequestVsyncErr"); + sptr window = sptr::MakeSptr(option); + std::shared_ptr vsyncCallback = std::make_shared(); + window->SetWindowState(WindowState::STATE_DESTROYED); + EXPECT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState()); + window->vsyncStation_ = nullptr; + window->RequestVsync(vsyncCallback); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: ClearVsync + * @tc.desc: Clear vsync test + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, ClearVsync, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("ClearVsync"); + sptr window = sptr::MakeSptr(option); + window->ClearVsyncStation(); + ASSERT_NE(window, nullptr); +} + +/** + * @tc.name: InitWindowProperty + * @tc.desc: InitWindowProperty Test + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, InitWindowProperty, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("InitWindowProperty"); + sptr window = sptr::MakeSptr(option); + window->InitWindowProperty(option); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: FindWindowById01 + * @tc.desc: Find one top window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, FindWindowById01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("FindWindowById01"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + ASSERT_NE(nullptr, window->FindWindowById(window->property_->GetWindowId())); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetWindowType01 + * @tc.desc: SetWindowType + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetWindowType01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetWindowType01"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_EQ(WMError::WM_OK, window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW)); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetWindowMode01 + * @tc.desc: SetWindowMode + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetWindowMode01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetWindowType01"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN)); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetWindowMode02 + * @tc.desc: Set window mode to split primary + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetWindowMode02, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName(""); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode()); + EXPECT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY)); + EXPECT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, window->GetWindowMode()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetWindowMode03 + * @tc.desc: Set window mode to split secondary + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetWindowMode03, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName(""); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode()); + EXPECT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY)); + EXPECT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, window->GetWindowMode()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetWindowMode04 + * @tc.desc: Set window mode to floating + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetWindowMode04, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName(""); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode()); + EXPECT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING)); + EXPECT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetWindowMode05 + * @tc.desc: Set window mode to pip + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetWindowMode05, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName(""); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode()); + EXPECT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_PIP)); + EXPECT_EQ(WindowMode::WINDOW_MODE_PIP, window->GetWindowMode()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: ShowHideWindow01 + * @tc.desc: Show and hide window with add and remove window ok + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, ShowHideWindow01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("ShowHideWindow01"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + window->NotifyForeground(); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Hide()); + window->NotifyBackground(); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: ShowHideWindow02 + * @tc.desc: Show window with add window WM_ERROR_SAMGR + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, ShowHideWindow02, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("ShowHideWindow02"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR)); + EXPECT_EQ(WMError::WM_ERROR_SAMGR, window->Show()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: ShowHideWindow03 + * @tc.desc: Show window with add window WM_ERROR_IPC_FAILED + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, ShowHideWindow03, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("ShowHideWindow03"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_IPC_FAILED)); + EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, window->Show()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: ShowHideWindow04 + * @tc.desc: Show window with add window OK & Hide window with remove window WM_ERROR_SAMGR + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, ShowHideWindow04, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("ShowHideWindow04"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR)); + EXPECT_EQ(WMError::WM_ERROR_SAMGR, window->Hide()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: ShowHideWindow05 + * @tc.desc: Hide window with remove window WM_ERROR_IPC_FAILED + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, ShowHideWindow05, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("ShowHideWindow05"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_IPC_FAILED)); + EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, window->Hide()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: ShowHideWindow06 + * @tc.desc: Hide window with remove window OK + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, ShowHideWindow06, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("ShowHideWindow06"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Hide()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetSystemBarProperty01 + * @tc.desc: SetSystemBarProperty with default param + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetSystemBarProperty01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetSystemBarProperty01"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR; + SystemBarProperty prop; + EXPECT_EQ(WMError::WM_OK, window->SetSystemBarProperty(type, prop)); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetSystemBarProperty02 + * @tc.desc: SetSystemBarProperty with adapter return WM_ERROR_SAMGR + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetSystemBarProperty02, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetSystemBarProperty02"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR)); + WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR; + const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333333); + EXPECT_EQ(WMError::WM_ERROR_SAMGR, window->SetSystemBarProperty(type, SYS_BAR_PROP)); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Hide(); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetSystemBarProperty03 + * @tc.desc: SetSystemBarProperty to invalid window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetSystemBarProperty03, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetSystemBarProperty03"); + sptr window = sptr::MakeSptr(option); + WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR; + SystemBarProperty prop; + EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSystemBarProperty(type, prop)); +} + +/** + * @tc.name: GetSystemBarPropertyByType01 + * @tc.desc: GetSystemBarPropertyByType with exist key + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetSystemBarPropertyByType01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("GetSystemBarPropertyByType01"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR; + const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333344); + EXPECT_EQ(WMError::WM_OK, window->SetSystemBarProperty(type, SYS_BAR_PROP)); + EXPECT_EQ(SYS_BAR_PROP, window->GetSystemBarPropertyByType(type)); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Hide(); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: GetSystemBarPropertyByType02 + * @tc.desc: GetSystemBarPropertyByType with nonexist key + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetSystemBarPropertyByType02, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("GetSystemBarPropertyByType02"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333333); + const SystemBarProperty DEFAULT_PROP; + EXPECT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP)); + EXPECT_EQ(DEFAULT_PROP, window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_NAVIGATION_BAR)); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Hide(); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: GetSystemBarPropertyByType03 + * @tc.desc: GetSystemBarPropertyByType with not systemBar type + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetSystemBarPropertyByType03, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("GetSystemBarPropertyByType03"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333366); + const SystemBarProperty DEFAULT_PROP; + EXPECT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP)); + EXPECT_EQ(DEFAULT_PROP, window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW)); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Hide(); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: Maximize02 + * @tc.desc: Maximize the sub window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, Maximize02, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("Maximize02"); + sptr window = sptr::MakeSptr(option); + window->Maximize(); + EXPECT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, window->GetWindowMode()); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + window->Maximize(); + EXPECT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode()); + + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Hide(); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: Recover01 + * @tc.desc: Recover the main window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, Recover01, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("Recover01"); + sptr window = sptr::MakeSptr(option); + EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Recover()); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Recover(); + EXPECT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode()); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Hide(); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: Recover02 + * @tc.desc: Recover the sub window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, Recover02, TestSize.Level1) +{ + std::unique_ptr m = std::make_unique(); + sptr option = sptr::MakeSptr(); + option->SetWindowName("Recover02"); + sptr window = sptr::MakeSptr(option); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + window->Recover(); + EXPECT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode()); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Hide(); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: Minimize01 + * @tc.desc: Minimize the main window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, Minimize01, TestSize.Level1) +{ + auto option = sptr::MakeSptr(); + option->SetWindowName("Minimize01"); + sptr window = sptr::MakeSptr(option); + EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Minimize()); + std::unique_ptr m = std::make_unique(); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + EXPECT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN)); + EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Minimize(); + EXPECT_FALSE((window->GetWindowState() == WindowState::STATE_SHOWN)); + window->uiContent_ = std::make_unique(); + EXPECT_EQ(WMError::WM_OK, window->Minimize()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + Ace::UIContentMocker* content = reinterpret_cast(window->uiContent_.get()); + EXPECT_CALL(*content, Destroy()); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: Minimize02 + * @tc.desc: Minimize the sub window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, Minimize02, TestSize.Level1) +{ + auto option = sptr::MakeSptr(); + option->SetWindowName("Minimize02"); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + window->Show(); + EXPECT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN)); + window->Minimize(); + EXPECT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN)); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: Minimize03 + * @tc.desc: Minimize + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, Minimize03, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("Minimize03"); + sptr window = sptr::MakeSptr(option); + WMError res = window->Minimize(); + EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, res); +} + +/** + * @tc.name: IsSupportWideGamut01 + * @tc.desc: IsSupportWideGamut + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, IsSupportWideGamut01, TestSize.Level1) +{ + auto option = sptr::MakeSptr(); + option->SetWindowName("IsSupportWideGamut01"); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + EXPECT_TRUE(window->IsSupportWideGamut()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetColorSpace01 + * @tc.desc: SetColorSpace + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetColorSpace01, TestSize.Level1) +{ + auto option = sptr::MakeSptr(); + option->SetWindowName("SetColorSpace01"); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + window->SetColorSpace(ColorSpace::COLOR_SPACE_WIDE_GAMUT); + EXPECT_EQ(ColorSpace::COLOR_SPACE_WIDE_GAMUT, window->GetColorSpace()); + window->SetColorSpace(ColorSpace::COLOR_SPACE_DEFAULT); + EXPECT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace()); + uint32_t invalidColorSpace = 1234u; + window->SetColorSpace(static_cast(invalidColorSpace)); + EXPECT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: GetColorSpace01 + * @tc.desc: GetColorSpace + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetColorSpace01, TestSize.Level1) +{ + auto option = sptr::MakeSptr(); + option->SetWindowName("GetColorSpace01"); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Create(INVALID_WINDOW_ID); + window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + window->SetColorSpace(ColorSpace::COLOR_SPACE_DEFAULT); + EXPECT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace()); + window->SetColorSpace(ColorSpace::COLOR_SPACE_WIDE_GAMUT); + EXPECT_EQ(ColorSpace::COLOR_SPACE_WIDE_GAMUT, window->GetColorSpace()); + uint32_t invalidColorSpace = 54321u; + window->SetColorSpace(static_cast(invalidColorSpace)); + EXPECT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: StartMove01 + * @tc.desc: start move main fullscreen window, test startMoveFlag + * @tc.type: FUNC + * @tc.require: issueI5J8IB + */ +HWTEST_F(WindowImplNewTest, StartMove01, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("StartMove01"); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + window->StartMove(); + EXPECT_FALSE(window->moveDragProperty_->startMoveFlag_); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: StartMove02 + * @tc.desc: start move main fullscreen window, test startMoveFlag + * @tc.type: FUNC + * @tc.require: issueI5J8IB + */ +HWTEST_F(WindowImplNewTest, StartMove02, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("StartMove02"); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + + window->StartMove(); + EXPECT_FALSE(window->moveDragProperty_->startMoveFlag_); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: StartMove03 + * @tc.desc: start move divider, test startMoveFlag + * @tc.type: FUNC + * @tc.require: issueI5J8IB + */ +HWTEST_F(WindowImplNewTest, StartMove03, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("StartMove03"); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + option->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + window->StartMove(); + EXPECT_FALSE(window->moveDragProperty_->startMoveFlag_); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetBackgroundColor01 + * @tc.desc: test SetBackgroundColor withow uiContent + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetBackgroundColor01, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetBackgroundColor01"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + window->Show(); + EXPECT_FALSE(window->IsTransparent()); + EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackgroundColor("#000")); + EXPECT_FALSE(window->IsTransparent()); + EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor("#00FF00")); + EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor("#FF00FF00")); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetTurnScreenOn01 + * @tc.desc: create window but not show, test SetTurnScreenOn + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetTurnScreenOn01, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetTurnScreenOn01"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTurnScreenOn(true)); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_FALSE(window->IsTurnScreenOn()); + EXPECT_EQ(WMError::WM_OK, window->SetTurnScreenOn(true)); + EXPECT_TRUE(window->IsTurnScreenOn()); + EXPECT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false)); + EXPECT_FALSE(window->IsTurnScreenOn()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetTurnScreenOn02 + * @tc.desc: create window with show, test SetTurnScreenOn + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetTurnScreenOn02, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetTurnScreenOn02"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_FALSE(window->IsTurnScreenOn()); + EXPECT_CALL(m->Mock(), UpdateProperty(_, _)) + .Times(2) + .WillOnce(Return(WMError::WM_OK)) + .WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->SetTurnScreenOn(true)); + EXPECT_TRUE(window->IsTurnScreenOn()); + EXPECT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false)); + EXPECT_FALSE(window->IsTurnScreenOn()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetKeepScreenOn01 + * @tc.desc: create window but not show, test SetKeepScreenOn + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetKeepScreenOn01, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetKeepScreenOn01"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetKeepScreenOn(true)); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_FALSE(window->IsKeepScreenOn()); + EXPECT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true)); + EXPECT_TRUE(window->IsKeepScreenOn()); + EXPECT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false)); + EXPECT_FALSE(window->IsKeepScreenOn()); + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetKeepScreenOn02 + * @tc.desc: create window with show, test SetKeepScreenOn + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetKeepScreenOn02, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetKeepScreenOn02"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_FALSE(window->IsKeepScreenOn()); + EXPECT_CALL(m->Mock(), UpdateProperty(_, _)) + .Times(2) + .WillOnce(Return(WMError::WM_OK)) + .WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true)); + EXPECT_TRUE(window->IsKeepScreenOn()); + EXPECT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false)); + EXPECT_FALSE(window->IsKeepScreenOn()); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetBrightness01 + * @tc.desc: test SetBrightness with invalid brightness + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetBrightness01, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetBrightness01"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetBrightness(0.f)); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_EQ(WMError::WM_OK, window->SetBrightness(MAXIMUM_BRIGHTNESS)); + + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness()); + EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBrightness(2.0f)); // 2.0f: brightness + EXPECT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness()); + EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBrightness(-0.5f)); // -0.5f: brightness + EXPECT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness()); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetBrightness02 + * @tc.desc: test SetBrightness with valid brightness + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetBrightness02, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetBrightness02"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness()); + EXPECT_CALL(m->Mock(), UpdateProperty(_, _)) + .Times(2) + .WillOnce(Return(WMError::WM_OK)) + .WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->SetBrightness(MAXIMUM_BRIGHTNESS)); + EXPECT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness()); + EXPECT_EQ(WMError::WM_OK, window->SetBrightness(MINIMUM_BRIGHTNESS)); + EXPECT_EQ(MINIMUM_BRIGHTNESS, window->GetBrightness()); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetBrightness03 + * @tc.desc: test SetBrightness with invalid type window + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, SetBrightness03, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("SetBrightness03"); + option->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + EXPECT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness()); + EXPECT_EQ(WMError::WM_ERROR_INVALID_TYPE, window->SetBrightness(MAXIMUM_BRIGHTNESS)); + EXPECT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness()); + + EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: RequestVsync + * @tc.desc: RequestVsync test + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, RequestVsync, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("RequestVsync"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + sptr window = sptr::MakeSptr(option); + std::unique_ptr m = std::make_unique(); + window->RestoreSplitWindowMode(0u); + EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); + EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); + + EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); + EXPECT_EQ(WMError::WM_OK, window->Show()); + std::shared_ptr callback = std::make_shared(); + window->SetWindowState(WindowState::STATE_DESTROYED); + EXPECT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState()); + window->RequestVsync(callback); + + EXPECT_EQ(WMError::WM_OK, window->Destroy()); + window->SetWindowState(WindowState::STATE_DESTROYED); + EXPECT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState()); + window->RequestVsync(callback); +} + +/** + * @tc.name: Create3 + * @tc.desc: Create3 WindowCreateCheck + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, Create3, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("WindowCreateCheck2"); + option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED); + option->SetWindowType(WindowType::WINDOW_TYPE_VOLUME_OVERLAY); + option->SetWindowRect({ 1, 1, 1, 1 }); + option->SetBundleName("OK"); + sptr window = sptr::MakeSptr(option); + + std::shared_ptr context = std::make_shared(); + WMError res = window->Create(1, context); + EXPECT_EQ(WMError::WM_ERROR_INVALID_PARENT, res); + EXPECT_EQ(WMError::WM_OK, window->Destroy()); +} + +/** + * @tc.name: SetRestoredRouterStack_0100 + * @tc.desc: basic function test of set or get restored router stack. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(WindowImplNewTest, SetRestoredRouterStack_0100, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + sptr window = sptr::MakeSptr(option); + std::string routerStack = "stackInfo:{}"; + EXPECT_EQ(window->SetRestoredRouterStack(routerStack), WMError::WM_OK); + std::string gettedStack = window->GetRestoredRouterStack(); + EXPECT_EQ(gettedStack, routerStack); + EXPECT_TRUE(window->GetRestoredRouterStack().empty()); +} + +/** + * @tc.name: GetWindowPropertyInfo + * @tc.desc: GetWindowPropertyInfo01 + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetWindowPropertyInfo01, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetFocusable(false); + option->SetTouchable(true); + option->SetDisplayId(999); + option->SetWindowName("GetWindowPropertyInfo01"); + sptr window = sptr::MakeSptr(option); + window->state_ = WindowState::STATE_DESTROYED; + WindowPropertyInfo windowPropertyInfo; + auto ret = window->GetWindowPropertyInfo(windowPropertyInfo); + EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret); +} + +/** + * @tc.name: GetWindowPropertyInfo + * @tc.desc: GetWindowPropertyInfo02 + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetWindowPropertyInfo02, TestSize.Level1) +{ + sptr option = sptr::MakeSptr(); + option->SetFocusable(false); + option->SetTouchable(true); + option->SetDisplayId(999); + option->SetWindowName("GetWindowPropertyInfo02"); + sptr window = sptr::MakeSptr(option); + window->state_ = WindowState::STATE_SHOWN; + WindowPropertyInfo windowPropertyInfo; + auto ret = window->GetWindowPropertyInfo(windowPropertyInfo); + EXPECT_EQ(WMError::WM_OK, ret); + EXPECT_EQ(false, windowPropertyInfo.isFocusable); + EXPECT_EQ(true, windowPropertyInfo.isTouchable); + EXPECT_EQ(999, windowPropertyInfo.displayId); +} + +/** + * @tc.name: GetWindowTypeForArkUI + * @tc.desc: get and verify WindowType + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetWindowTypeForArkUI001, TestSize.Level1) +{ + WindowType windowType; + auto ret = WindowImpl::GetWindowTypeForArkUI(WindowType::WINDOW_TYPE_SCENE_BOARD, windowType); + EXPECT_EQ(WMError::WM_OK, ret); + EXPECT_EQ(windowType == WindowType::WINDOW_TYPE_SYSTEM_FLOAT, true); +} + +/** + * @tc.name: GetWindowTypeForArkUI + * @tc.desc: get and verify WindowType + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetWindowTypeForArkUI002, TestSize.Level1) +{ + WindowType windowType; + auto ret = WindowImpl::GetWindowTypeForArkUI(WindowType::WINDOW_TYPE_DESKTOP, windowType); + EXPECT_EQ(WMError::WM_OK, ret); + EXPECT_EQ(windowType == WindowType::WINDOW_TYPE_SYSTEM_FLOAT, true); +} + +/** + * @tc.name: GetWindowTypeForArkUI + * @tc.desc: get and verify WindowType + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetWindowTypeForArkUI003, TestSize.Level1) +{ + WindowType windowType; + auto ret = WindowImpl::GetWindowTypeForArkUI(WindowType::WINDOW_TYPE_UI_EXTENSION, windowType); + EXPECT_EQ(WMError::WM_OK, ret); + EXPECT_EQ(windowType == WindowType::WINDOW_TYPE_APP_SUB_WINDOW, true); +} + +/** + * @tc.name: GetWindowTypeForArkUI + * @tc.desc: get and verify WindowType + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetWindowTypeForArkUI004, TestSize.Level1) +{ + WindowType windowType; + auto ret = WindowImpl::GetWindowTypeForArkUI(WindowType::WINDOW_TYPE_FLOAT, windowType); + EXPECT_EQ(WMError::WM_OK, ret); + EXPECT_EQ(windowType == WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW, true); +} + +/** + * @tc.name: GetWindowTypeForArkUI + * @tc.desc: get and verify WindowType + * @tc.type: FUNC + */ +HWTEST_F(WindowImplNewTest, GetWindowTypeForArkUI005, TestSize.Level1) +{ + WindowType windowType; + auto ret = WindowImpl::GetWindowTypeForArkUI(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, windowType); + EXPECT_EQ(WMError::WM_OK, ret); + EXPECT_EQ(windowType == WindowType::WINDOW_TYPE_APP_SUB_WINDOW, true); +} +} // namespace +} // namespace Rosen +} // namespace OHOS -- Gitee