1/* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include <gtest/gtest.h> 17#include "iremote_object_mocker.h" 18#include "window_manager.h" 19#include "mock_window_adapter.h" 20#include "singleton_mocker.h" 21#include "scene_board_judgement.h" 22#include "scene_session_manager.h" 23 24#include "window_manager.cpp" 25 26using namespace testing; 27using namespace testing::ext; 28 29namespace OHOS { 30namespace Rosen { 31using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>; 32class TestCameraFloatWindowChangedListener : public ICameraFloatWindowChangedListener { 33public: 34 void OnCameraFloatWindowChange(uint32_t accessTokenId, bool isShowing) override 35 { 36 WLOGI("TestCameraFloatWindowChangedListener [%{public}u, %{public}u]", accessTokenId, isShowing); 37 }; 38}; 39 40class TestVisibilityChangedListener : public IVisibilityChangedListener { 41public: 42 void OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfo) override 43 { 44 WLOGI("TestVisibilityChangedListener"); 45 }; 46}; 47 48class TestSystemBarChangedListener : public ISystemBarChangedListener { 49public: 50 void OnSystemBarPropertyChange(DisplayId displayId, const SystemBarRegionTints& tints) override 51 { 52 WLOGI("TestSystemBarChangedListener"); 53 }; 54}; 55 56class TestWindowUpdateListener : public IWindowUpdateListener { 57public: 58 void OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>>& infos, WindowUpdateType type) override 59 { 60 WLOGI("TestWindowUpdateListener"); 61 }; 62}; 63 64class TestWindowModeChangedListener : public IWindowModeChangedListener { 65public: 66 void OnWindowModeUpdate(WindowModeType mode) override 67 { 68 WLOGI("TestWindowModeChangedListener"); 69 }; 70}; 71 72class TestWaterMarkFlagChangeListener : public IWaterMarkFlagChangedListener { 73public: 74 void OnWaterMarkFlagUpdate(bool showWaterMark) override 75 { 76 WLOGI("TestWaterMarkFlagChangeListener"); 77 }; 78}; 79 80class TestGestureNavigationEnabledChangedListener : public IGestureNavigationEnabledChangedListener { 81public: 82 void OnGestureNavigationEnabledUpdate(bool enable) override 83 { 84 WLOGI("TestGestureNavigationEnabledChangedListener"); 85 }; 86}; 87 88class TestDisplayInfoChangedListener : public IDisplayInfoChangedListener { 89public: 90 void OnDisplayInfoChange(const sptr<IRemoteObject>& token, DisplayId displayId, float density, 91 DisplayOrientation orientation) override 92 { 93 TLOGI(WmsLogTag::DMS, "TestDisplayInfoChangedListener"); 94 } 95}; 96 97class TestVisibleWindowNumChangedListener : public IVisibleWindowNumChangedListener { 98public: 99 void OnVisibleWindowNumChange(const std::vector<VisibleWindowNumInfo>& visibleWindowNumInfo) override 100 { 101 for (const auto& num : visibleWindowNumInfo) { 102 GTEST_LOG_(INFO) << "displayId " << num.displayId << ", visibleWindowNum " << num.visibleWindowNum; 103 } 104 }; 105}; 106 107class TestDrawingContentChangedListener : public IDrawingContentChangedListener { 108public: 109 void OnWindowDrawingContentChanged(const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingInfo) 110 { 111 TLOGI(WmsLogTag::DMS, "TestDrawingContentChangedListener"); 112 } 113}; 114 115class TestFocusChangedListener : public IFocusChangedListener { 116public: 117 void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo) 118 { 119 TLOGI(WmsLogTag::DMS, "TestFocusChangedListener OnFocused()"); 120 } 121 void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo) 122 { 123 TLOGI(WmsLogTag::DMS, "TestFocusChangedListener OnUnfocused()"); 124 } 125}; 126 127class TestWindowStyleChangedListener : public IWindowStyleChangedListener { 128public: 129 void OnWindowStyleUpdate(WindowStyleType styleType) 130 { 131 TLOGI(WmsLogTag::DMS, "TestWindowStyleChangedListener"); 132 } 133}; 134 135class TestWindowPidVisibilityChangedListener : public IWindowPidVisibilityChangedListener { 136public: 137 void NotifyWindowPidVisibilityChanged(const sptr<WindowPidVisibilityInfo>& info) 138 { 139 TLOGI(WmsLogTag::DMS, "TestWindowPidVisibilityChangedListener"); 140 } 141}; 142 143class WindowManagerTest : public testing::Test { 144public: 145 static void SetUpTestCase(); 146 static void TearDownTestCase(); 147 void SetUp() override; 148 void TearDown() override; 149}; 150 151void WindowManagerTest::SetUpTestCase() 152{ 153} 154 155void WindowManagerTest::TearDownTestCase() 156{ 157} 158 159void WindowManagerTest::SetUp() 160{ 161} 162 163void WindowManagerTest::TearDown() 164{ 165} 166 167namespace { 168/** 169 * @tc.name: Create01 170 * @tc.desc: Create window with no WindowName and no abilityToken 171 * @tc.type: FUNC 172 */ 173HWTEST_F(WindowManagerTest, GetVisibilityWindowInfo01, Function | SmallTest | Level2) 174{ 175 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 176 std::vector<sptr<WindowVisibilityInfo>> infos; 177 infos.clear(); 178 EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 179 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetVisibilityWindowInfo(infos)); 180 EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW)); 181 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetVisibilityWindowInfo(infos)); 182} 183 184/** 185 * @tc.name: ToggleShownStateForAllAppWindows 186 * @tc.desc: ToggleShownStateForAllAppWindows ok 187 * @tc.type: FUNC 188 */ 189HWTEST_F(WindowManagerTest, ToggleShownStateForAllAppWindows, Function | SmallTest | Level2) 190{ 191 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 192 EXPECT_CALL(m->Mock(), ToggleShownStateForAllAppWindows()).Times(1).WillOnce(Return(WMError::WM_OK)); 193 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().ToggleShownStateForAllAppWindows()); 194} 195 196/** 197 * @tc.name: Create01 198 * @tc.desc: Create window with no WindowName and no abilityToken 199 * @tc.type: FUNC 200 */ 201HWTEST_F(WindowManagerTest, GetAccessibilityWindowInfo01, Function | SmallTest | Level2) 202{ 203 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 204 std::vector<sptr<AccessibilityWindowInfo>> infos; 205 infos.clear(); 206 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 207 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos)); 208 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW)); 209 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos)); 210} 211 212/** 213 * @tc.name: GetSnapshotByWindowId01 214 * @tc.desc: Check GetSnapshotByWindowId01 215 * @tc.type: FUNC 216 */ 217HWTEST_F(WindowManagerTest, GetSnapshotByWindowId01, Function | SmallTest | Level2) 218{ 219 auto& windowManager = WindowManager::GetInstance(); 220 int32_t windowId = -1; 221 std::shared_ptr<Media::PixelMap> pixelMap = nullptr; 222 WMError ret = windowManager.GetSnapshotByWindowId(windowId, pixelMap); 223 if (SceneBoardJudgement::IsSceneBoardEnabled()) { 224 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); 225 }else { 226 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 227 } 228} 229 230/* 231 * @tc.name: GetUnreliableWindowInfo 232 * @tc.desc: GetUnreliableWindowInfo ok 233 * @tc.type: FUNC 234 */ 235HWTEST_F(WindowManagerTest, GetUnreliableWindowInfo, Function | SmallTest | Level2) 236{ 237 std::unique_ptr<Mocker> mocker = std::make_unique<Mocker>(); 238 int32_t windowId = 0; 239 std::vector<sptr<UnreliableWindowInfo>> infos; 240 EXPECT_CALL(mocker->Mock(), GetUnreliableWindowInfo(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 241 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetUnreliableWindowInfo(windowId, infos)); 242} 243 244/** 245 * @tc.name: RegisterCameraFloatWindowChangedListener01 246 * @tc.desc: check RegisterCameraFloatWindowChangedListener 247 * @tc.type: FUNC 248 */ 249HWTEST_F(WindowManagerTest, RegisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2) 250{ 251 auto& windowManager = WindowManager::GetInstance(); 252 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_; 253 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_; 254 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = nullptr; 255 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear(); 256 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(nullptr)); 257 258 sptr<TestCameraFloatWindowChangedListener> listener = new TestCameraFloatWindowChangedListener(); 259 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 260 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR)); 261 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(listener)); 262 263 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 264 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener)); 265 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size()); 266 267 // to check that the same listner can not be registered twice 268 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 269 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener)); 270 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size()); 271 272 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent; 273 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners; 274} 275 276/** 277 * @tc.name: UnregisterCameraFloatWindowChangedListener01 278 * @tc.desc: check UnregisterCameraFloatWindowChangedListener 279 * @tc.type: FUNC 280 */ 281HWTEST_F(WindowManagerTest, UnregisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2) 282{ 283 auto& windowManager = WindowManager::GetInstance(); 284 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_; 285 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_; 286 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = new WindowManagerAgent(); 287 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear(); 288 289 // check nullpter 290 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraFloatWindowChangedListener(nullptr)); 291 292 sptr<TestCameraFloatWindowChangedListener> listener1 = new TestCameraFloatWindowChangedListener(); 293 sptr<TestCameraFloatWindowChangedListener> listener2 = new TestCameraFloatWindowChangedListener(); 294 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1)); 295 296 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 297 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 298 windowManager.RegisterCameraFloatWindowChangedListener(listener1); 299 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 300 windowManager.RegisterCameraFloatWindowChangedListener(listener2); 301 ASSERT_EQ(2, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size()); 302 303 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1)); 304 305 306 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 307 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener2)); 308 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size()); 309 ASSERT_EQ(nullptr, windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_); 310 311 windowManager.pImpl_->cameraFloatWindowChangedListeners_.emplace_back(listener1); 312 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1)); 313 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size()); 314 315 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent; 316 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners; 317} 318 319/** 320 * @tc.name: RegisterVisibilityChangedListener01 321 * @tc.desc: check RegisterVisibilityChangedListener 322 * @tc.type: FUNC 323 */ 324HWTEST_F(WindowManagerTest, RegisterVisibilityChangedListener01, Function | SmallTest | Level2) 325{ 326 auto& windowManager = WindowManager::GetInstance(); 327 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_; 328 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_; 329 windowManager.pImpl_->windowVisibilityListenerAgent_ = nullptr; 330 windowManager.pImpl_->windowVisibilityListeners_.clear(); 331 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(nullptr)); 332 333 sptr<TestVisibilityChangedListener> listener = new TestVisibilityChangedListener(); 334 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 335 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR)); 336 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(listener)); 337 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_); 338 339 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 340 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener)); 341 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size()); 342 343 // to check that the same listner can not be registered twice 344 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 345 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener)); 346 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size()); 347 348 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent; 349 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners; 350} 351 352/** 353 * @tc.name: UnregisterVisibilityChangedListener01 354 * @tc.desc: check UnregisterVisibilityChangedListener 355 * @tc.type: FUNC 356 */ 357HWTEST_F(WindowManagerTest, UnregisterVisibilityChangedListener01, Function | SmallTest | Level2) 358{ 359 auto& windowManager = WindowManager::GetInstance(); 360 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_; 361 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_; 362 windowManager.pImpl_->windowVisibilityListenerAgent_ = new WindowManagerAgent(); 363 windowManager.pImpl_->windowVisibilityListeners_.clear(); 364 365 // check nullpter 366 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityChangedListener(nullptr)); 367 368 sptr<TestVisibilityChangedListener> listener1 = new TestVisibilityChangedListener(); 369 sptr<TestVisibilityChangedListener> listener2 = new TestVisibilityChangedListener(); 370 371 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 372 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 373 windowManager.RegisterVisibilityChangedListener(listener1); 374 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 375 windowManager.RegisterVisibilityChangedListener(listener2); 376 ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityListeners_.size()); 377 378 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1)); 379 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 380 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener2)); 381 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size()); 382 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_); 383 384 windowManager.pImpl_->windowVisibilityListeners_.emplace_back(listener1); 385 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1)); 386 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size()); 387 388 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent; 389 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners; 390} 391 392/** 393 * @tc.name: RegisterWindowUpdateListener01 394 * @tc.desc: check RegisterWindowUpdateListener 395 * @tc.type: FUNC 396 */ 397HWTEST_F(WindowManagerTest, RegisterWindowUpdateListener01, Function | SmallTest | Level2) 398{ 399 auto& windowManager = WindowManager::GetInstance(); 400 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_; 401 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_; 402 windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr; 403 windowManager.pImpl_->windowUpdateListeners_.clear(); 404 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr)); 405 406 sptr<TestWindowUpdateListener> listener = new TestWindowUpdateListener(); 407 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 408 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR)); 409 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener)); 410 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_); 411 412 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 413 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener)); 414 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size()); 415 416 // to check that the same listner can not be registered twice 417 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 418 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener)); 419 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size()); 420 421 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent; 422 windowManager.pImpl_->windowUpdateListeners_ = oldListeners; 423} 424 425/** 426 * @tc.name: UnregisterWindowUpdateListener01 427 * @tc.desc: check UnregisterWindowUpdateListener 428 * @tc.type: FUNC 429 */ 430HWTEST_F(WindowManagerTest, UnregisterWindowUpdateListener01, Function | SmallTest | Level2) 431{ 432 auto& windowManager = WindowManager::GetInstance(); 433 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_; 434 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_; 435 windowManager.pImpl_->windowUpdateListenerAgent_ = new WindowManagerAgent(); 436 windowManager.pImpl_->windowUpdateListeners_.clear(); 437 438 // check nullpter 439 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr)); 440 441 sptr<TestWindowUpdateListener> listener1 = new TestWindowUpdateListener(); 442 sptr<TestWindowUpdateListener> listener2 = new TestWindowUpdateListener(); 443 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1)); 444 445 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 446 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 447 windowManager.RegisterWindowUpdateListener(listener1); 448 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 449 windowManager.RegisterWindowUpdateListener(listener2); 450 ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size()); 451 452 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1)); 453 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 454 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2)); 455 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size()); 456 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_); 457 458 windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1); 459 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1)); 460 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size()); 461 462 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent; 463 windowManager.pImpl_->windowUpdateListeners_ = oldListeners; 464} 465 466/** 467 * @tc.name: RegisterWindowModeChangedListener01 468 * @tc.desc: check RegisterWindowModeChangedListener 469 * @tc.type: FUNC 470 */ 471HWTEST_F(WindowManagerTest, RegisterWindowModeChangedListener01, Function | SmallTest | Level2) 472{ 473 auto &windowManager = WindowManager::GetInstance(); 474 auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_; 475 auto oldListeners = windowManager.pImpl_->windowModeListeners_; 476 windowManager.pImpl_->windowModeListenerAgent_ = nullptr; 477 windowManager.pImpl_->windowModeListeners_.clear(); 478 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(nullptr)); 479 480 sptr<TestWindowModeChangedListener> listener = new TestWindowModeChangedListener(); 481 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 482 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR)); 483 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(listener)); 484 ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_); 485 486 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 487 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener)); 488 ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size()); 489 490 // to check that the same listner can not be registered twice 491 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 492 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener)); 493 ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size()); 494 495 windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent; 496 windowManager.pImpl_->windowModeListeners_ = oldListeners; 497} 498 499/** 500 * @tc.name: UnregisterWindowModeChangedListener01 501 * @tc.desc: check UnregisterWindowModeChangedListener 502 * @tc.type: FUNC 503 */ 504HWTEST_F(WindowManagerTest, UnregisterWindowModeChangedListener01, Function | SmallTest | Level2) 505{ 506 auto &windowManager = WindowManager::GetInstance(); 507 auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_; 508 auto oldListeners = windowManager.pImpl_->windowModeListeners_; 509 windowManager.pImpl_->windowModeListenerAgent_ = new WindowManagerAgent(); 510 windowManager.pImpl_->windowModeListeners_.clear(); 511 512 // check nullpter 513 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowModeChangedListener(nullptr)); 514 515 sptr<TestWindowModeChangedListener> listener1 = new TestWindowModeChangedListener(); 516 sptr<TestWindowModeChangedListener> listener2 = new TestWindowModeChangedListener(); 517 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1)); 518 519 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 520 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 521 windowManager.RegisterWindowModeChangedListener(listener1); 522 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 523 windowManager.RegisterWindowModeChangedListener(listener2); 524 ASSERT_EQ(2, windowManager.pImpl_->windowModeListeners_.size()); 525 526 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1)); 527 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 528 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener2)); 529 ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size()); 530 ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_); 531 532 windowManager.pImpl_->windowModeListeners_.emplace_back(listener1); 533 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1)); 534 ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size()); 535 536 windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent; 537 windowManager.pImpl_->windowModeListeners_ = oldListeners; 538} 539 540/** 541 * @tc.name: RegisterSystemBarChangedListener01 542 * @tc.desc: check RegisterSystemBarChangedListener 543 * @tc.type: FUNC 544 */ 545HWTEST_F(WindowManagerTest, RegisterSystemBarChangedListener01, Function | SmallTest | Level2) 546{ 547 auto& windowManager = WindowManager::GetInstance(); 548 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_; 549 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_; 550 windowManager.pImpl_->systemBarChangedListenerAgent_ = nullptr; 551 windowManager.pImpl_->systemBarChangedListeners_.clear(); 552 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(nullptr)); 553 554 sptr<ISystemBarChangedListener> listener = new TestSystemBarChangedListener(); 555 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 556 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR)); 557 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(listener)); 558 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_); 559 560 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 561 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener)); 562 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size()); 563 564 // to check that the same listner can not be registered twice 565 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 566 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener)); 567 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size()); 568 569 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent; 570 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners; 571} 572 573/** 574 * @tc.name: UnregisterSystemBarChangedListener01 575 * @tc.desc: check UnregisterSystemBarChangedListener 576 * @tc.type: FUNC 577 */ 578HWTEST_F(WindowManagerTest, UnregisterSystemBarChangedListener01, Function | SmallTest | Level2) 579{ 580 auto& windowManager = WindowManager::GetInstance(); 581 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_; 582 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_; 583 windowManager.pImpl_->systemBarChangedListenerAgent_ = new WindowManagerAgent(); 584 windowManager.pImpl_->systemBarChangedListeners_.clear(); 585 // check nullpter 586 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterSystemBarChangedListener(nullptr)); 587 588 sptr<TestSystemBarChangedListener> listener1 = new TestSystemBarChangedListener(); 589 sptr<TestSystemBarChangedListener> listener2 = new TestSystemBarChangedListener(); 590 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1)); 591 592 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 593 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 594 windowManager.RegisterSystemBarChangedListener(listener1); 595 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 596 windowManager.RegisterSystemBarChangedListener(listener2); 597 ASSERT_EQ(2, windowManager.pImpl_->systemBarChangedListeners_.size()); 598 599 600 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1)); 601 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 602 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener2)); 603 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size()); 604 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_); 605 606 windowManager.pImpl_->systemBarChangedListeners_.push_back(listener1); 607 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1)); 608 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size()); 609 610 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent; 611 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners; 612} 613 614/** 615 * @tc.name: RegisterWaterMarkListener01 616 * @tc.desc: check RegisterWaterMarkListener 617 * @tc.type: FUNC 618 */ 619HWTEST_F(WindowManagerTest, RegisterWaterMarkFlagChangedListener01, Function | SmallTest | Level2) 620{ 621 auto& windowManager = WindowManager::GetInstance(); 622 623 windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr; 624 windowManager.pImpl_->waterMarkFlagChangeListeners_.clear(); 625 626 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(nullptr)); 627 628 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 629 sptr<TestWaterMarkFlagChangeListener> listener = new TestWaterMarkFlagChangeListener(); 630 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR)); 631 632 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(listener)); 633 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size()); 634 ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_); 635 636 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 637 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener)); 638 ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size()); 639 ASSERT_NE(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_); 640 641 // to check that the same listner can not be registered twice 642 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 643 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener)); 644 ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size()); 645} 646 647/** 648 * @tc.name: UnregisterWaterMarkFlagChangedListener01 649 * @tc.desc: check UnregisterWaterMarkFlagChangedListener 650 * @tc.type: FUNC 651 */ 652HWTEST_F(WindowManagerTest, UnregisterWaterMarkFlagChangedListener01, Function | SmallTest | Level2) 653{ 654 auto& windowManager = WindowManager::GetInstance(); 655 windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr; 656 windowManager.pImpl_->waterMarkFlagChangeListeners_.clear(); 657 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 658 659 // check nullpter 660 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWaterMarkFlagChangedListener(nullptr)); 661 662 sptr<TestWaterMarkFlagChangeListener> listener1 = new TestWaterMarkFlagChangeListener(); 663 sptr<TestWaterMarkFlagChangeListener> listener2 = new TestWaterMarkFlagChangeListener(); 664 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1)); 665 666 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 667 windowManager.RegisterWaterMarkFlagChangedListener(listener1); 668 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 669 windowManager.RegisterWaterMarkFlagChangedListener(listener2); 670 ASSERT_EQ(2, windowManager.pImpl_->waterMarkFlagChangeListeners_.size()); 671 672 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 673 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1)); 674 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener2)); 675 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size()); 676 ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_); 677 678 // if agent == nullptr, it can not be crashed. 679 windowManager.pImpl_->waterMarkFlagChangeListeners_.push_back(listener1); 680 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1)); 681 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size()); 682} 683 684/** 685 * @tc.name: RegisterGestureNavigationEnabledChangedListener 686 * @tc.desc: check RegisterGestureNavigationEnabledChangedListener 687 * @tc.type: FUNC 688 */ 689HWTEST_F(WindowManagerTest, RegisterGestureNavigationEnabledChangedListener, Function | SmallTest | Level2) 690{ 691 auto& windowManager = WindowManager::GetInstance(); 692 693 windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr; 694 windowManager.pImpl_->gestureNavigationEnabledListeners_.clear(); 695 696 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(nullptr)); 697 698 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 699 sptr<TestGestureNavigationEnabledChangedListener> listener = new TestGestureNavigationEnabledChangedListener(); 700 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR)); 701 702 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(listener)); 703 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size()); 704 ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_); 705 706 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 707 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener)); 708 ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size()); 709 ASSERT_NE(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_); 710 711 // to check that the same listner can not be registered twice 712 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 713 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener)); 714 ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size()); 715} 716 717/** 718 * @tc.name: UnregisterGestureNavigationEnabledChangedListener 719 * @tc.desc: check UnregisterGestureNavigationEnabledChangedListener 720 * @tc.type: FUNC 721 */ 722HWTEST_F(WindowManagerTest, UnregisterGestureNavigationEnabledChangedListener, Function | SmallTest | Level2) 723{ 724 auto& windowManager = WindowManager::GetInstance(); 725 windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr; 726 windowManager.pImpl_->gestureNavigationEnabledListeners_.clear(); 727 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 728 729 // check nullpter 730 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterGestureNavigationEnabledChangedListener(nullptr)); 731 732 sptr<TestGestureNavigationEnabledChangedListener> listener1 = new TestGestureNavigationEnabledChangedListener(); 733 sptr<TestGestureNavigationEnabledChangedListener> listener2 = new TestGestureNavigationEnabledChangedListener(); 734 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, 735 windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1)); 736 737 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 738 windowManager.RegisterGestureNavigationEnabledChangedListener(listener1); 739 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 740 windowManager.RegisterGestureNavigationEnabledChangedListener(listener2); 741 ASSERT_EQ(2, windowManager.pImpl_->gestureNavigationEnabledListeners_.size()); 742 743 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 744 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1)); 745 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener2)); 746 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size()); 747 ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_); 748 749 // if agent == nullptr, it can not be crashed. 750 windowManager.pImpl_->gestureNavigationEnabledListeners_.push_back(listener1); 751 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1)); 752 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size()); 753} 754 755/** 756 * @tc.name: GetUIContentRemoteObj 757 * @tc.desc: GetUIContentRemoteObj 758 * @tc.type: FUNC 759 */ 760HWTEST_F(WindowManagerTest, GetUIContentRemoteObj, Function | SmallTest | Level2) 761{ 762 sptr<IRemoteObject> remoteObj; 763 WMError res = WindowManager::GetInstance().GetUIContentRemoteObj(1, remoteObj); 764 if (SceneBoardJudgement::IsSceneBoardEnabled()) { 765 ASSERT_EQ(res, WMError::WM_ERROR_IPC_FAILED); 766 return; 767 } 768 ASSERT_EQ(res, WMError::WM_OK); 769} 770 771/** 772 * @tc.name: GetFocusWindowInfo 773 * @tc.desc: window GetFocusWindowInfo 774 * @tc.type: FUNC 775 */ 776HWTEST_F(WindowManagerTest, GetFocusWindowInfo, Function | SmallTest | Level2) 777{ 778 FocusChangeInfo focusInfo; 779 auto ret = 0; 780 WindowManager::GetInstance().GetFocusWindowInfo(focusInfo); 781 ASSERT_EQ(0, ret); 782} 783 784/** 785 * @tc.name: MinimizeAllAppWindows 786 * @tc.desc: window MinimizeAllAppWindows 787 * @tc.type: FUNC 788 */ 789HWTEST_F(WindowManagerTest, MinimizeAllAppWindows, Function | SmallTest | Level2) 790{ 791 DisplayId displayId = 0; 792 WMError ret = WindowManager::GetInstance().MinimizeAllAppWindows(displayId); 793 ASSERT_NE(ret, WMError::WM_OK); 794} 795 796/** 797 * @tc.name: SetWindowLayoutMode 798 * @tc.desc: window SetWindowLayoutMode 799 * @tc.type: FUNC 800 */ 801HWTEST_F(WindowManagerTest, SetWindowLayoutMode, Function | SmallTest | Level2) 802{ 803 WMError ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::BASE); 804 ASSERT_EQ(ret, WMError::WM_OK); 805 806 ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE); 807 ASSERT_EQ(ret, WMError::WM_OK); 808 809 ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::END); 810 ASSERT_EQ(ret, WMError::WM_OK); 811} 812 813/** 814 * @tc.name: SkipSnapshotForAppProcess 815 * @tc.desc: check SkipSnapshotForAppProcess 816 * @tc.type: FUNC 817 */ 818HWTEST_F(WindowManagerTest, SkipSnapshotForAppProcess, Function | SmallTest | Level2) 819{ 820 int32_t pid = 1000; 821 bool skip = true; 822 auto ret = WindowManager::GetInstance().SkipSnapshotForAppProcess(pid, skip); 823 ASSERT_EQ(WMError::WM_OK, ret); 824} 825 826/** 827 * @tc.name: UpdateCameraFloatWindowStatus 828 * @tc.desc: UpdateCameraFloatWindowStatus 829 * @tc.type: FUNC 830 */ 831HWTEST_F(WindowManagerTest, UpdateCameraFloatWindowStatus, Function | SmallTest | Level2) 832{ 833 uint32_t accessTokenId = 0; 834 bool isShowing = true; 835 auto ret = 0; 836 WindowManager::GetInstance().UpdateCameraFloatWindowStatus(accessTokenId, isShowing); 837 ASSERT_EQ(0, ret); 838} 839 840/** 841 * @tc.name: NotifyWaterMarkFlagChangedResult 842 * @tc.desc: NotifyWaterMarkFlagChangedResult 843 * @tc.type: FUNC 844 */ 845HWTEST_F(WindowManagerTest, NotifyWaterMarkFlagChangedResult, Function | SmallTest | Level2) 846{ 847 bool showwatermark = true; 848 auto ret = 0; 849 WindowManager::GetInstance().NotifyWaterMarkFlagChangedResult(showwatermark); 850 ASSERT_EQ(0, ret); 851} 852 853/** 854 * @tc.name: NotifyGestureNavigationEnabledResult 855 * @tc.desc: NotifyGestureNavigationEnabledResult 856 * @tc.type: FUNC 857 */ 858HWTEST_F(WindowManagerTest, NotifyGestureNavigationEnabledResult, Function | SmallTest | Level2) 859{ 860 bool enable = true; 861 auto ret = 0; 862 WindowManager::GetInstance().NotifyGestureNavigationEnabledResult(enable); 863 ASSERT_EQ(0, ret); 864} 865 866/** 867 * @tc.name: DumpSessionAll 868 * @tc.desc: DumpSessionAll 869 * @tc.type: FUNC 870 */ 871HWTEST_F(WindowManagerTest, DumpSessionAll, Function | SmallTest | Level2) 872{ 873 std::vector<std::string> infos; 874 infos.push_back("DumpSessionWithId"); 875 WMError res = WindowManager::GetInstance().DumpSessionAll(infos); 876 ASSERT_EQ(WMError::WM_OK, res); 877} 878 879/** 880 * @tc.name: DumpSessionWithId 881 * @tc.desc: DumpSessionWithId 882 * @tc.type: FUNC 883 */ 884HWTEST_F(WindowManagerTest, DumpSessionWithId, Function | SmallTest | Level2) 885{ 886 std::vector<std::string> infos; 887 infos.push_back("DumpSessionWithId"); 888 int32_t persistentId = 0; 889 WMError res = WindowManager::GetInstance().DumpSessionWithId(persistentId, infos); 890 ASSERT_EQ(WMError::WM_OK, res); 891} 892 893/** 894 * @tc.name: RegisterVisibleWindowNumChangedListener 895 * @tc.desc: check RegisterVisibleWindowNumChangedListener 896 * @tc.type: FUNC 897 */ 898HWTEST_F(WindowManagerTest, RegisterVisibleWindowNumChangedListener, Function | SmallTest | Level2) 899{ 900 auto& windowManager = WindowManager::GetInstance(); 901 902 windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr; 903 windowManager.pImpl_->visibleWindowNumChangedListeners_.clear(); 904 905 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibleWindowNumChangedListener(nullptr)); 906 907 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 908 sptr<TestVisibleWindowNumChangedListener> listener = new TestVisibleWindowNumChangedListener(); 909 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR)); 910 911 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibleWindowNumChangedListener(listener)); 912 ASSERT_EQ(0, windowManager.pImpl_->visibleWindowNumChangedListeners_.size()); 913 ASSERT_EQ(nullptr, windowManager.pImpl_->visibleWindowNumChangedListenerAgent_); 914 915 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 916 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener)); 917 ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size()); 918 ASSERT_NE(nullptr, windowManager.pImpl_->visibleWindowNumChangedListenerAgent_); 919 920 // to check that the same listner can not be registered twice 921 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 922 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener)); 923 ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size()); 924} 925 926/** 927 * @tc.name: UnregisterVisibleWindowNumChangedListener 928 * @tc.desc: check UnregisterVisibleWindowNumChangedListener 929 * @tc.type: FUNC 930 */ 931HWTEST_F(WindowManagerTest, UnregisterVisibleWindowNumChangedListener, Function | SmallTest | Level2) 932{ 933 auto& windowManager = WindowManager::GetInstance(); 934 windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr; 935 windowManager.pImpl_->visibleWindowNumChangedListeners_.clear(); 936 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 937 938 // check nullpter 939 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibleWindowNumChangedListener(nullptr)); 940 941 sptr<TestVisibleWindowNumChangedListener> listener1 = new TestVisibleWindowNumChangedListener(); 942 sptr<TestVisibleWindowNumChangedListener> listener2 = new TestVisibleWindowNumChangedListener(); 943 944 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 945 windowManager.RegisterVisibleWindowNumChangedListener(listener1); 946 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 947 windowManager.RegisterVisibleWindowNumChangedListener(listener2); 948 ASSERT_EQ(2, windowManager.pImpl_->visibleWindowNumChangedListeners_.size()); 949 950 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener1)); 951 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener2)); 952 ASSERT_EQ(2, windowManager.pImpl_->visibleWindowNumChangedListeners_.size()); 953 954 // if agent == nullptr, it can not be crashed. 955 windowManager.pImpl_->visibleWindowNumChangedListeners_.push_back(listener1); 956 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener1)); 957 ASSERT_EQ(3, windowManager.pImpl_->visibleWindowNumChangedListeners_.size()); 958} 959 960/** 961 * @tc.name: RegisterAndOnVisibleWindowNumChanged 962 * @tc.desc: check RegisterAndOnVisibleWindowNumChanged 963 * @tc.type: FUNC 964 */ 965HWTEST_F(WindowManagerTest, RegisterAndOnVisibleWindowNumChanged, Function | SmallTest | Level2) 966{ 967 auto& windowManager = WindowManager::GetInstance(); 968 windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr; 969 windowManager.pImpl_->visibleWindowNumChangedListeners_.clear(); 970 971 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 972 sptr<TestVisibleWindowNumChangedListener> listener = new TestVisibleWindowNumChangedListener(); 973 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 974 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener)); 975 ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size()); 976 977 std::vector<VisibleWindowNumInfo> visibleWindowNumInfo; 978 VisibleWindowNumInfo newInfo; 979 newInfo.displayId = 0; 980 newInfo.visibleWindowNum = 2; 981 visibleWindowNumInfo.push_back(newInfo); 982 auto ret = 0; 983 windowManager.UpdateVisibleWindowNum(visibleWindowNumInfo); 984 ASSERT_EQ(0, ret); 985} 986 987/** 988 * @tc.name: Test01 989 * @tc.desc: Test01 990 * @tc.type: FUNC 991 */ 992HWTEST_F(WindowManagerTest, Test01, Function | SmallTest | Level2) 993{ 994 sptr<IWMSConnectionChangedListener> listener = nullptr; 995 WMError res = WindowManager::GetInstance().RegisterWMSConnectionChangedListener(listener); 996 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, res); 997 WMError res1 = WindowManager::GetInstance().UnregisterWMSConnectionChangedListener(); 998 ASSERT_EQ(WMError::WM_OK, res1); 999 WindowManager::GetInstance().RaiseWindowToTop(5); 1000 WMError res3 = WindowManager::GetInstance().NotifyWindowExtensionVisibilityChange(5, 5, true); 1001 ASSERT_EQ(WMError::WM_OK, res3); 1002 WindowManager::GetInstance().ShiftAppWindowFocus(0, 1); 1003} 1004 1005HWTEST_F(WindowManagerTest, GetWindowModeType01, Function | SmallTest | Level2) 1006{ 1007 std::vector<sptr<AccessibilityWindowInfo>> infos; 1008 infos.clear(); 1009 WindowModeType windowModeType; 1010 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 1011 EXPECT_CALL(m->Mock(), GetWindowModeType(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 1012 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetWindowModeType(windowModeType)); 1013} 1014 1015/** 1016 * @tc.name: RegisterDisplayInfoChangedListener 1017 * @tc.desc: check RegisterDisplayInfoChangedListener 1018 * @tc.type: FUNC 1019 */ 1020HWTEST_F(WindowManagerTest, RegisterDisplayInfoChangedListener, Function | SmallTest | Level2) 1021{ 1022 auto& windowManager = WindowManager::GetInstance(); 1023 windowManager.pImpl_->displayInfoChangedListeners_.clear(); 1024 1025 sptr<IRemoteObject> targetToken = nullptr; 1026 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(targetToken, nullptr)); 1027 1028 targetToken = new (std::nothrow) IRemoteObjectMocker(); 1029 ASSERT_NE(nullptr, targetToken); 1030 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(targetToken, nullptr)); 1031 1032 sptr<IDisplayInfoChangedListener> listener = new (std::nothrow) TestDisplayInfoChangedListener(); 1033 ASSERT_NE(nullptr, listener); 1034 sptr<IDisplayInfoChangedListener> listener2 = new (std::nothrow) TestDisplayInfoChangedListener(); 1035 ASSERT_NE(nullptr, listener2); 1036 1037 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(nullptr, listener)); 1038 ASSERT_EQ(0, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1039 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener)); 1040 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1041 1042 // to check that the same listner can not be registered twice 1043 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener)); 1044 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1045 1046 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener2)); 1047 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1048 auto iter = windowManager.pImpl_->displayInfoChangedListeners_.find(targetToken); 1049 ASSERT_NE(windowManager.pImpl_->displayInfoChangedListeners_.end(), iter); 1050 ASSERT_EQ(2, iter->second.size()); 1051} 1052 1053/** 1054 * @tc.name: UnregisterDisplayInfoChangedListener 1055 * @tc.desc: check UnregisterDisplayInfoChangedListener 1056 * @tc.type: FUNC 1057 */ 1058HWTEST_F(WindowManagerTest, UnregisterDisplayInfoChangedListener, Function | SmallTest | Level2) 1059{ 1060 auto& windowManager = WindowManager::GetInstance(); 1061 windowManager.pImpl_->displayInfoChangedListeners_.clear(); 1062 1063 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(nullptr, nullptr)); 1064 1065 sptr<IRemoteObject> targetToken = new (std::nothrow) IRemoteObjectMocker(); 1066 ASSERT_NE(nullptr, targetToken); 1067 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(targetToken, nullptr)); 1068 1069 sptr<IDisplayInfoChangedListener> listener = new (std::nothrow) TestDisplayInfoChangedListener(); 1070 ASSERT_NE(nullptr, listener); 1071 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(nullptr, listener)); 1072 1073 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener)); 1074 1075 sptr<IRemoteObject> targetToken2 = new (std::nothrow) IRemoteObjectMocker(); 1076 ASSERT_NE(nullptr, targetToken2); 1077 sptr<IDisplayInfoChangedListener> listener2 = new (std::nothrow) TestDisplayInfoChangedListener(); 1078 ASSERT_NE(nullptr, listener2); 1079 1080 // the same token can have multiple listeners 1081 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener)); 1082 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1083 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener2)); 1084 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1085 auto iter = windowManager.pImpl_->displayInfoChangedListeners_.find(targetToken); 1086 ASSERT_NE(windowManager.pImpl_->displayInfoChangedListeners_.end(), iter); 1087 ASSERT_EQ(2, iter->second.size()); 1088 1089 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken2, listener)); 1090 ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1091 1092 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener)); 1093 ASSERT_EQ(1, iter->second.size()); 1094 ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1095 1096 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener2)); 1097 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1098 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken2, listener)); 1099 ASSERT_EQ(0, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1100} 1101 1102/** 1103 * @tc.name: NotifyDisplayInfoChanged 1104 * @tc.desc: check NotifyDisplayInfoChanged 1105 * @tc.type: FUNC 1106 */ 1107HWTEST_F(WindowManagerTest, NotifyDisplayInfoChanged, Function | SmallTest | Level2) 1108{ 1109 sptr<IRemoteObject> targetToken = new (std::nothrow) IRemoteObjectMocker(); 1110 ASSERT_NE(nullptr, targetToken); 1111 DisplayId displayId = 0; 1112 float density = 0.2f; 1113 DisplayOrientation orientation = DisplayOrientation::UNKNOWN; 1114 1115 auto& windowManager = WindowManager::GetInstance(); 1116 windowManager.pImpl_->displayInfoChangedListeners_.clear(); 1117 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation); 1118 1119 sptr<IRemoteObject> targetToken2 = new (std::nothrow) IRemoteObjectMocker(); 1120 ASSERT_NE(nullptr, targetToken2); 1121 sptr<IDisplayInfoChangedListener> listener = new (std::nothrow) TestDisplayInfoChangedListener(); 1122 ASSERT_NE(nullptr, listener); 1123 1124 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener)); 1125 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1126 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation); 1127 1128 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken2, listener)); 1129 ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size()); 1130 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation); 1131 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken2, displayId, density, orientation); 1132 // no repeated notification is sent if parameters do not change 1133 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation); 1134} 1135 1136/** 1137 * @tc.name: RegisterWindowStyleChangedListener 1138 * @tc.desc: check RegisterWindowStyleChangedListener 1139 * @tc.type: FUNC 1140 */ 1141HWTEST_F(WindowManagerTest, RegisterWindowStyleChangedListener, Function | SmallTest | Level2) 1142{ 1143 auto& windowManager = WindowManager::GetInstance(); 1144 auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_; 1145 auto oldListeners = windowManager.pImpl_->windowStyleListeners_; 1146 windowManager.pImpl_->windowStyleListenerAgent_ = nullptr; 1147 windowManager.pImpl_->windowStyleListeners_.clear(); 1148 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(nullptr)); 1149 1150 sptr<IWindowStyleChangedListener> listener = new TestWindowStyleChangedListener(); 1151 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 1152} 1153 1154/** 1155 * @tc.name: UnregisterWindowStyleChangedListener 1156 * @tc.desc: check UnregisterWindowStyleChangedListener 1157 * @tc.type: FUNC 1158 */ 1159HWTEST_F(WindowManagerTest, UnregisterWindowStyleChangedListener, Function | SmallTest | Level2) 1160{ 1161 auto& windowManager = WindowManager::GetInstance(); 1162 auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_; 1163 auto oldListeners = windowManager.pImpl_->windowStyleListeners_; 1164 windowManager.pImpl_->windowStyleListenerAgent_ = new WindowManagerAgent(); 1165 windowManager.pImpl_->windowStyleListeners_.clear(); 1166 // check nullpter 1167 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowStyleChangedListener(nullptr)); 1168 1169 sptr<TestWindowStyleChangedListener> listener1 = new TestWindowStyleChangedListener(); 1170 sptr<TestWindowStyleChangedListener> listener2 = new TestWindowStyleChangedListener(); 1171 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1)); 1172} 1173 1174/** 1175 * @tc.name: NotifyWindowStyleChange 1176 * @tc.desc: check NotifyWindowStyleChange 1177 * @tc.type: FUNC 1178 */ 1179HWTEST_F(WindowManagerTest, NotifyWindowStyleChange, Function | SmallTest | Level2) 1180{ 1181 WindowStyleType type = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT; 1182 auto ret = WindowManager::GetInstance().NotifyWindowStyleChange(type); 1183 ASSERT_EQ(WMError::WM_OK, ret); 1184} 1185 1186/** 1187 * @tc.name: GetWindowStyleType 1188 * @tc.desc: check GetWindowStyleType 1189 * @tc.type: FUNC 1190 */ 1191HWTEST_F(WindowManagerTest, GetWindowStyleType, Function | SmallTest | Level2) 1192{ 1193 WindowStyleType type; 1194 type = WindowManager::GetInstance().GetWindowStyleType(); 1195 ASSERT_EQ(Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT, type); 1196} 1197 1198/** 1199 * @tc.name: ShiftAppWindowFocus01 1200 * @tc.desc: check ShiftAppWindowFocus 1201 * @tc.type: FUNC 1202 */ 1203HWTEST_F(WindowManagerTest, ShiftAppWindowFocus01, Function | SmallTest | Level2) 1204{ 1205 WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1); 1206 ASSERT_NE(WMError::WM_OK, ret); 1207} 1208 1209/** 1210 * @tc.name: RegisterVisibleWindowNumChangedListener01 1211 * @tc.desc: check RegisterVisibleWindowNumChangedListener 1212 * @tc.type: FUNC 1213 */ 1214HWTEST_F(WindowManagerTest, RegisterVisibleWindowNumChangedListener01, Function | SmallTest | Level2) 1215{ 1216 WMError ret; 1217 sptr<IVisibleWindowNumChangedListener> listener = new (std::nothrow) TestVisibleWindowNumChangedListener(); 1218 ret = WindowManager::GetInstance().RegisterVisibleWindowNumChangedListener(listener); 1219 ASSERT_NE(WMError::WM_OK, ret); 1220 1221 ret = WindowManager::GetInstance().RegisterVisibleWindowNumChangedListener(nullptr); 1222 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 1223} 1224 1225/** 1226 * @tc.name: UnregisterVisibleWindowNumChangedListener01 1227 * @tc.desc: check UnregisterVisibleWindowNumChangedListener 1228 * @tc.type: FUNC 1229 */ 1230HWTEST_F(WindowManagerTest, UnregisterVisibleWindowNumChangedListener01, Function | SmallTest | Level2) 1231{ 1232 WMError ret; 1233 sptr<IVisibleWindowNumChangedListener> listener = new (std::nothrow) TestVisibleWindowNumChangedListener(); 1234 ret = WindowManager::GetInstance().UnregisterVisibleWindowNumChangedListener(listener); 1235 ASSERT_EQ(WMError::WM_OK, ret); 1236 1237 ret = WindowManager::GetInstance().UnregisterVisibleWindowNumChangedListener(nullptr); 1238 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 1239} 1240 1241/** 1242 * @tc.name: RegisterDrawingContentChangedListener01 1243 * @tc.desc: check RegisterDrawingContentChangedListener 1244 * @tc.type: FUNC 1245 */ 1246HWTEST_F(WindowManagerTest, RegisterDrawingContentChangedListener01, Function | SmallTest | Level2) 1247{ 1248 WMError ret; 1249 sptr<IDrawingContentChangedListener> listener = new (std::nothrow) TestDrawingContentChangedListener(); 1250 ret = WindowManager::GetInstance().RegisterDrawingContentChangedListener(listener); 1251 ASSERT_NE(WMError::WM_OK, ret); 1252 1253 ret = WindowManager::GetInstance().RegisterDrawingContentChangedListener(nullptr); 1254 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 1255} 1256 1257/** 1258 * @tc.name: UnregisterDrawingContentChangedListener01 1259 * @tc.desc: check UnregisterDrawingContentChangedListener 1260 * @tc.type: FUNC 1261 */ 1262HWTEST_F(WindowManagerTest, UnregisterDrawingContentChangedListener01, Function | SmallTest | Level2) 1263{ 1264 WMError ret; 1265 sptr<IDrawingContentChangedListener> listener = new (std::nothrow) TestDrawingContentChangedListener(); 1266 ret = WindowManager::GetInstance().UnregisterDrawingContentChangedListener(listener); 1267 ASSERT_EQ(WMError::WM_OK, ret); 1268 1269 ret = WindowManager::GetInstance().UnregisterDrawingContentChangedListener(nullptr); 1270 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 1271} 1272 1273/** 1274 * @tc.name: RegisterFocusChangedListener01 1275 * @tc.desc: check RegisterFocusChangedListener 1276 * @tc.type: FUNC 1277 */ 1278HWTEST_F(WindowManagerTest, RegisterFocusChangedListener01, Function | SmallTest | Level2) 1279{ 1280 WMError ret; 1281 sptr<IFocusChangedListener> listener = new (std::nothrow) TestFocusChangedListener(); 1282 ret = WindowManager::GetInstance().RegisterFocusChangedListener(listener); 1283 ASSERT_NE(WMError::WM_OK, ret); 1284 1285 ret = WindowManager::GetInstance().RegisterFocusChangedListener(nullptr); 1286 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 1287} 1288 1289/** 1290 * @tc.name: UnregisterFocusChangedListener01 1291 * @tc.desc: check UnregisterFocusChangedListener 1292 * @tc.type: FUNC 1293 */ 1294HWTEST_F(WindowManagerTest, UnregisterFocusChangedListener01, Function | SmallTest | Level2) 1295{ 1296 WMError ret; 1297 sptr<IFocusChangedListener> listener = new (std::nothrow) TestFocusChangedListener(); 1298 ret = WindowManager::GetInstance().UnregisterFocusChangedListener(listener); 1299 ASSERT_EQ(WMError::WM_OK, ret); 1300 1301 ret = WindowManager::GetInstance().UnregisterFocusChangedListener(nullptr); 1302 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 1303} 1304 1305/** 1306 * @tc.name: SetProcessWatermark 1307 * @tc.desc: check SetProcessWatermark 1308 * @tc.type: FUNC 1309 */ 1310HWTEST_F(WindowManagerTest, SetProcessWatermark, Function | SmallTest | Level2) 1311{ 1312 int32_t pid = 1000; 1313 const std::string watermarkName = "SetProcessWatermarkName"; 1314 bool isEnabled = true; 1315 auto ret = WindowManager::GetInstance().SetProcessWatermark(pid, watermarkName, isEnabled); 1316 ASSERT_EQ(WMError::WM_OK, ret); 1317} 1318 1319/** 1320 * @tc.name: NotifyDisplayInfoChange01 1321 * @tc.desc: check NotifyDisplayInfoChange, Token is nullptr 1322 * @tc.type: FUNC 1323 */ 1324HWTEST_F(WindowManagerTest, NotifyDisplayInfoChange01, Function | SmallTest | Level2) 1325{ 1326 WMError ret = WindowManager::GetInstance().NotifyDisplayInfoChange(nullptr, 1, 2, DisplayOrientation::PORTRAIT); 1327 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); 1328} 1329 1330/** 1331 * @tc.name: NotifyDisplayInfoChange02 1332 * @tc.desc: check NotifyDisplayInfoChange, Token is nullptr 1333 * @tc.type: FUNC 1334 */ 1335HWTEST_F(WindowManagerTest, NotifyDisplayInfoChange02, Function | SmallTest | Level2) 1336{ 1337 sptr<IRemoteObject> Token = new (std::nothrow) IRemoteObjectMocker(); 1338 ASSERT_NE(Token, nullptr); 1339 WMError ret = WindowManager::GetInstance().NotifyDisplayInfoChange(Token, 1, 2, DisplayOrientation::PORTRAIT); 1340 ASSERT_EQ(WMError::WM_OK, ret); 1341} 1342 1343/** 1344 * @tc.name: NotifyWMSDisconnected01 1345 * @tc.desc: check NotifyWMSDisconnected 1346 * @tc.type: FUNC 1347 */ 1348HWTEST_F(WindowManagerTest, NotifyWMSDisconnected01, Function | SmallTest | Level2) 1349{ 1350 WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1); 1351 ASSERT_NE(WMError::WM_OK, ret); 1352 WindowManager::GetInstance().pImpl_->NotifyWMSDisconnected(1, 2); 1353} 1354 1355/** 1356 * @tc.name: NotifyFocused01 1357 * @tc.desc: check NotifyFocused 1358 * @tc.type: FUNC 1359 */ 1360HWTEST_F(WindowManagerTest, NotifyFocused01, Function | SmallTest | Level2) 1361{ 1362 sptr<FocusChangeInfo> focusChangeInfo = new FocusChangeInfo(); 1363 ASSERT_NE(focusChangeInfo, nullptr); 1364 1365 WindowManager::GetInstance().pImpl_->NotifyFocused(focusChangeInfo); 1366} 1367 1368/** 1369 * @tc.name: NotifyUnfocused01 1370 * @tc.desc: check NotifyUnfocused 1371 * @tc.type: FUNC 1372 */ 1373HWTEST_F(WindowManagerTest, NotifyUnfocused01, Function | SmallTest | Level2) 1374{ 1375 sptr<FocusChangeInfo> focusChangeInfo = new FocusChangeInfo(); 1376 ASSERT_NE(focusChangeInfo, nullptr); 1377 1378 WindowManager::GetInstance().pImpl_->NotifyUnfocused(focusChangeInfo); 1379} 1380 1381/** 1382 * @tc.name: NotifyAccessibilityWindowInfo01 1383 * @tc.desc: check NotifyAccessibilityWindowInfo 1384 * @tc.type: FUNC 1385 */ 1386HWTEST_F(WindowManagerTest, NotifyAccessibilityWindowInfo01, Function | SmallTest | Level2) 1387{ 1388 WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1); 1389 ASSERT_NE(WMError::WM_OK, ret); 1390 sptr<AccessibilityWindowInfo> info = new (std::nothrow) AccessibilityWindowInfo(); 1391 ASSERT_NE(info, nullptr); 1392 1393 std::vector<sptr<AccessibilityWindowInfo>> infos; 1394 infos.push_back(info); 1395 WindowManager::GetInstance().pImpl_->NotifyAccessibilityWindowInfo(infos, WindowUpdateType::WINDOW_UPDATE_ACTIVE); 1396 1397 infos.clear(); 1398 infos.push_back(nullptr); 1399 WindowManager::GetInstance().pImpl_->NotifyAccessibilityWindowInfo(infos, WindowUpdateType::WINDOW_UPDATE_ACTIVE); 1400} 1401 1402/** 1403 * @tc.name: NotifyVisibleWindowNumChanged01 1404 * @tc.desc: check NotifyVisibleWindowNumChanged 1405 * @tc.type: FUNC 1406 */ 1407HWTEST_F(WindowManagerTest, NotifyVisibleWindowNumChanged01, Function | SmallTest | Level2) 1408{ 1409 std::vector<VisibleWindowNumInfo> visibleWindowNumInfo; 1410 WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.clear(); 1411 WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.push_back(nullptr); 1412 WindowManager::GetInstance().pImpl_->NotifyVisibleWindowNumChanged(visibleWindowNumInfo); 1413 1414 sptr<IVisibleWindowNumChangedListener> listener = new (std::nothrow) TestVisibleWindowNumChangedListener(); 1415 ASSERT_NE(listener, nullptr); 1416 WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.clear(); 1417 WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.push_back(listener); 1418 WindowManager::GetInstance().pImpl_->NotifyVisibleWindowNumChanged(visibleWindowNumInfo); 1419} 1420 1421/** 1422 * @tc.name: RegisterWindowPidVisibilityChangedListener 1423 * @tc.desc: check RegisterWindowPidVisibilityChangedListener 1424 * @tc.type: FUNC 1425 */ 1426HWTEST_F(WindowManagerTest, RegisterWindowPidVisibilityChangedListener, Function | SmallTest | Level2) 1427{ 1428 WMError ret; 1429 sptr<IWindowPidVisibilityChangedListener> listener = new (std::nothrow) TestWindowPidVisibilityChangedListener(); 1430 ASSERT_NE(nullptr, listener); 1431 ret = WindowManager::GetInstance().RegisterWindowPidVisibilityChangedListener(listener); 1432 ASSERT_EQ(WMError::WM_OK, ret); 1433 1434 ret = WindowManager::GetInstance().RegisterWindowPidVisibilityChangedListener(nullptr); 1435 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 1436} 1437 1438/** 1439 * @tc.name: UnregisterWindowPidVisibilityChangedListener 1440 * @tc.desc: check UnregisterWindowPidVisibilityChangedListener 1441 * @tc.type: FUNC 1442 */ 1443HWTEST_F(WindowManagerTest, UnregisterWindowPidVisibilityChangedListener, Function | SmallTest | Level2) 1444{ 1445 WMError ret; 1446 sptr<IWindowPidVisibilityChangedListener> listener = new (std::nothrow) TestWindowPidVisibilityChangedListener(); 1447 ret = WindowManager::GetInstance().UnregisterWindowPidVisibilityChangedListener(listener); 1448 ASSERT_EQ(WMError::WM_OK, ret); 1449 1450 ret = WindowManager::GetInstance().UnregisterWindowPidVisibilityChangedListener(nullptr); 1451 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret); 1452} 1453 1454/** 1455 * @tc.name: NotifyWindowPidVisibilityChanged 1456 * @tc.desc: NotifyWindowPidVisibilityChanged 1457 * @tc.type: FUNC 1458 */ 1459HWTEST_F(WindowManagerTest, NotifyWindowPidVisibilityChanged, Function | SmallTest | Level2) 1460{ 1461 sptr<WindowPidVisibilityInfo> info = new WindowPidVisibilityInfo(); 1462 WindowManager::GetInstance().NotifyWindowPidVisibilityChanged(info); 1463 ASSERT_NE(info, nullptr); 1464} 1465 1466/** 1467 * @tc.name: ReleaseForegroundSessionScreenLock 1468 * @tc.desc: check ReleaseForegroundSessionScreenLock 1469 * @tc.type: FUNC 1470 */ 1471HWTEST_F(WindowManagerTest, ReleaseForegroundSessionScreenLock, Function | SmallTest | Level2) 1472{ 1473 auto ret = WindowManager::GetInstance().ReleaseForegroundSessionScreenLock(); 1474 ASSERT_EQ(ret, WMError::WM_OK); 1475} 1476} 1477} // namespace Rosen 1478} // namespace OHOS