1/* 2 * Copyright (c) 2024 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 "ability_context_impl.h" 18#include "display_manager_proxy.h" 19#include "mock_window_adapter.h" 20#include "singleton_mocker.h" 21#include "window_impl.h" 22#include "mock_uicontent.h" 23 24using namespace testing; 25using namespace testing::ext; 26 27namespace OHOS { 28namespace Rosen { 29using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>; 30class MockAceAbilityHandler : public IAceAbilityHandler { 31public: 32 MOCK_METHOD1(SetBackgroundColor, void(uint32_t color)); 33 MOCK_METHOD0(GetBackgroundColor, uint32_t()); 34}; 35 36class MockAnimationTransitionController : public IAnimationTransitionController { 37public: 38 MOCK_METHOD0(AnimationForShown, void()); 39 MOCK_METHOD0(AnimationForHidden, void()); 40}; 41 42class MockDialogDeathRecipientListener : public IDialogDeathRecipientListener { 43public: 44 MOCK_CONST_METHOD0(OnDialogDeathRecipient, void()); 45}; 46 47class MockScreenshotListener : public IScreenshotListener { 48public: 49 MOCK_METHOD0(OnScreenshot, void()); 50}; 51 52class MockDialogTargetTouchListener : public IDialogTargetTouchListener { 53public: 54 MOCK_CONST_METHOD0(OnDialogTargetTouch, void()); 55}; 56 57class MockWindowChangeListener : public IWindowChangeListener { 58public: 59 MOCK_METHOD3(OnSizeChange, void(Rect rect, WindowSizeChangeReason reason, 60 const std::shared_ptr<RSTransaction>& rsTransaction)); 61 MOCK_METHOD2(OnModeChange, void(WindowMode mode, bool hasDeco)); 62 MOCK_METHOD1(NotifyTransformChange, void(const Transform& transform)); 63}; 64 65class MockAvoidAreaChangedListener : public IAvoidAreaChangedListener { 66public: 67 MOCK_METHOD2(OnAvoidAreaChanged, void(const AvoidArea avoidArea, AvoidAreaType type)); 68}; 69 70class MockDisplayMoveListener : public IDisplayMoveListener { 71public: 72 MOCK_METHOD2(OnDisplayMove, void(DisplayId from, DisplayId to)); 73}; 74 75class MockInputEventConsumer : public IInputEventConsumer { 76public: 77 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::KeyEvent>&)); 78 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::PointerEvent>&)); 79 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::AxisEvent>&)); 80}; 81 82class MockKeyEvent : public MMI::KeyEvent { 83public: 84 MockKeyEvent() : MMI::KeyEvent(0) {} 85}; 86 87class MockPointerEvent : public MMI::PointerEvent { 88public: 89 MockPointerEvent() : MMI::PointerEvent(0) {} 90}; 91 92class WindowImplTest3 : public testing::Test { 93public: 94 static void SetUpTestCase(); 95 static void TearDownTestCase(); 96 void SetUp() override; 97 void TearDown() override; 98 99 static inline std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_; 100 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 101private: 102 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000; 103}; 104void WindowImplTest3::SetUpTestCase() 105{ 106} 107 108void WindowImplTest3::TearDownTestCase() 109{ 110} 111 112void WindowImplTest3::SetUp() 113{ 114} 115 116void WindowImplTest3::TearDown() 117{ 118 usleep(WAIT_SYNC_IN_NS); 119} 120 121namespace { 122/* 123 * @tc.name: RegisterAnimationTransitionController 124 * @tc.desc: RegisterAnimationTransitionController test 125 * @tc.type: FUNC 126 */ 127HWTEST_F(WindowImplTest3, RegisterAnimationTransitionController, Function | SmallTest | Level3) 128{ 129 sptr<WindowOption> option = new WindowOption(); 130 sptr<WindowImpl> window = new WindowImpl(option); 131 sptr<IAnimationTransitionController> listener; 132 ASSERT_EQ(nullptr, listener); 133 window->RegisterAnimationTransitionController(listener); 134 listener = new MockAnimationTransitionController(); 135 window->uiContent_ = std::make_unique<Ace::UIContentMocker>(); 136 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get()); 137 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_)); 138 window->RegisterAnimationTransitionController(listener); 139 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_)); 140 window->RegisterAnimationTransitionController(listener); 141 window->property_->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM)); 142 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_)); 143 window->RegisterAnimationTransitionController(listener); 144} 145 146/* 147 * @tc.name: RegisterDialogDeathRecipientListener 148 * @tc.desc: RegisterDialogDeathRecipientListener | NotifyDestroy test 149 * @tc.type: FUNC 150 */ 151HWTEST_F(WindowImplTest3, RegisterDialogDeathRecipientListener, Function | SmallTest | Level3) 152{ 153 sptr<WindowOption> option = new WindowOption(); 154 sptr<WindowImpl> window = new WindowImpl(option); 155 156 sptr<MockDialogDeathRecipientListener> listener; 157 ASSERT_EQ(nullptr, listener); 158 window->RegisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener)); 159 listener = new MockDialogDeathRecipientListener(); 160 ASSERT_NE(nullptr, listener); 161 window->RegisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener)); 162 EXPECT_CALL(*listener, OnDialogDeathRecipient()); 163 window->NotifyDestroy(); 164 window->UnregisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener)); 165 window->NotifyDestroy(); 166} 167 168/* 169 * @tc.name: NotifyScreenshot 170 * @tc.desc: NotifyScreenshot test 171 * @tc.type: FUNC 172 */ 173HWTEST_F(WindowImplTest3, NotifyScreenshot, Function | SmallTest | Level3) 174{ 175 sptr<WindowOption> option = new WindowOption(); 176 sptr<WindowImpl> window = new WindowImpl(option); 177 178 sptr<MockScreenshotListener> listener; 179 window->screenshotListeners_[window->GetWindowId()].push_back(sptr<IScreenshotListener>(listener)); 180 listener = new MockScreenshotListener; 181 window->screenshotListeners_[window->GetWindowId()].push_back(sptr<IScreenshotListener>(listener)); 182 EXPECT_CALL(*listener, OnScreenshot()).Times(1); 183 window->NotifyScreenshot(); 184 window->screenshotListeners_[window->GetWindowId()].clear(); 185} 186 187/* 188 * @tc.name: NotifyTouchDialogTarget 189 * @tc.desc: NotifyTouchDialogTarget test 190 * @tc.type: FUNC 191 */ 192HWTEST_F(WindowImplTest3, NotifyTouchDialogTarget, Function | SmallTest | Level3) 193{ 194 sptr<WindowOption> option = new WindowOption(); 195 sptr<WindowImpl> window = new WindowImpl(option); 196 197 sptr<MockDialogTargetTouchListener> listener; 198 window->dialogTargetTouchListeners_[window->GetWindowId()].push_back(sptr<IDialogTargetTouchListener>(listener)); 199 listener = new MockDialogTargetTouchListener; 200 window->dialogTargetTouchListeners_[window->GetWindowId()].push_back(sptr<IDialogTargetTouchListener>(listener)); 201 EXPECT_CALL(*listener, OnDialogTargetTouch()); 202 EXPECT_CALL(m->Mock(), ProcessPointDown(_, _)); 203 window->NotifyTouchDialogTarget(); 204 window->dialogTargetTouchListeners_[window->GetWindowId()].clear(); 205} 206 207/* 208 * @tc.name: NotifySizeChange 209 * @tc.desc: NotifySizeChange test 210 * @tc.type: FUNC 211 */ 212HWTEST_F(WindowImplTest3, NotifySizeChange, Function | SmallTest | Level3) 213{ 214 sptr<WindowOption> option = new WindowOption(); 215 sptr<WindowImpl> window = new WindowImpl(option); 216 217 sptr<MockWindowChangeListener> listener; 218 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener)); 219 listener = new MockWindowChangeListener; 220 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener)); 221 EXPECT_CALL(*listener, OnSizeChange(_, _, _)); 222 Rect rect; 223 window->NotifySizeChange(rect, WindowSizeChangeReason::UNDEFINED); 224 window->windowChangeListeners_[window->GetWindowId()].clear(); 225} 226 227/* 228 * @tc.name: NotifyModeChange 229 * @tc.desc: NotifyModeChange test 230 * @tc.type: FUNC 231 */ 232HWTEST_F(WindowImplTest3, NotifyModeChange, Function | SmallTest | Level3) 233{ 234 sptr<WindowOption> option = new WindowOption(); 235 sptr<WindowImpl> window = new WindowImpl(option); 236 237 sptr<MockWindowChangeListener> listener; 238 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener)); 239 listener = new MockWindowChangeListener; 240 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener)); 241 EXPECT_CALL(*listener, OnModeChange(_, _)); 242 window->NotifyModeChange(WindowMode::WINDOW_MODE_UNDEFINED); 243 window->windowChangeListeners_[window->GetWindowId()].clear(); 244} 245 246/* 247 * @tc.name: NotifyAvoidAreaChange 248 * @tc.desc: NotifyAvoidAreaChange test 249 * @tc.type: FUNC 250 */ 251HWTEST_F(WindowImplTest3, NotifyAvoidAreaChange, Function | SmallTest | Level3) 252{ 253 sptr<WindowOption> option = new WindowOption(); 254 sptr<WindowImpl> window = new WindowImpl(option); 255 256 sptr<MockAvoidAreaChangedListener> listener; 257 window->avoidAreaChangeListeners_[window->GetWindowId()].push_back(sptr<IAvoidAreaChangedListener>(listener)); 258 listener = new MockAvoidAreaChangedListener; 259 window->avoidAreaChangeListeners_[window->GetWindowId()].push_back(sptr<IAvoidAreaChangedListener>(listener)); 260 EXPECT_CALL(*listener, OnAvoidAreaChanged(_, _)); 261 sptr<AvoidArea> avoidArea = new AvoidArea; 262 window->NotifyAvoidAreaChange(avoidArea, AvoidAreaType::TYPE_CUTOUT); 263 window->avoidAreaChangeListeners_[window->GetWindowId()].clear(); 264} 265 266/* 267 * @tc.name: NotifyDisplayMoveChange 268 * @tc.desc: NotifyDisplayMoveChange test 269 * @tc.type: FUNC 270 */ 271HWTEST_F(WindowImplTest3, NotifyDisplayMoveChange, Function | SmallTest | Level3) 272{ 273 sptr<WindowOption> option = new WindowOption(); 274 sptr<WindowImpl> window = new WindowImpl(option); 275 276 sptr<MockDisplayMoveListener> listener; 277 window->displayMoveListeners_.push_back(sptr<IDisplayMoveListener>(listener)); 278 listener = new MockDisplayMoveListener; 279 window->displayMoveListeners_.push_back(sptr<IDisplayMoveListener>(listener)); 280 EXPECT_CALL(*listener, OnDisplayMove(_, _)); 281 window->NotifyDisplayMoveChange(DisplayId{}, DisplayId{}); 282} 283 284/* 285 * @tc.name: SetAceAbilityHandler 286 * @tc.desc: SetAceAbilityHandler test 287 * @tc.type: FUNC 288 */ 289HWTEST_F(WindowImplTest3, SetAceAbilityHandler, Function | SmallTest | Level3) 290{ 291 sptr<WindowOption> option = new WindowOption(); 292 sptr<WindowImpl> window = new WindowImpl(option); 293 294 sptr<IAceAbilityHandler> handler; 295 ASSERT_EQ(nullptr, handler); 296 window->SetAceAbilityHandler(handler); 297 handler = new MockAceAbilityHandler(); 298 ASSERT_NE(nullptr, handler); 299 window->SetAceAbilityHandler(handler); 300} 301 302/* 303 * @tc.name: HandleBackKeyPressedEvent 304 * @tc.desc: HandleBackKeyPressedEvent test 305 * @tc.type: FUNC 306 */ 307HWTEST_F(WindowImplTest3, HandleBackKeyPressedEvent, Function | SmallTest | Level3) 308{ 309 sptr<WindowOption> option = new WindowOption(); 310 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 311 sptr<WindowImpl> window = new WindowImpl(option); 312 ASSERT_EQ(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, window->GetType()); 313 std::shared_ptr<MMI::KeyEvent> keyEvent; 314 window->HandleBackKeyPressedEvent(keyEvent); 315 316 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 317 window->uiContent_ = std::make_unique<Ace::UIContentMocker>(); 318 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get()); 319 EXPECT_CALL(*content, ProcessBackPressed()).WillOnce(Return(false)); 320 window->HandleBackKeyPressedEvent(keyEvent); 321 322 window->inputEventConsumer_.reset(new MockInputEventConsumer); 323 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()), 324 OnInputEvent(keyEvent)).WillOnce(Return(true)); 325 window->HandleBackKeyPressedEvent(keyEvent); 326} 327 328/* 329 * @tc.name: ConsumeKeyEvent 330 * @tc.desc: ConsumeKeyEvent test 331 * @tc.type: FUNC 332 */ 333HWTEST_F(WindowImplTest3, ConsumeKeyEvent, Function | SmallTest | Level3) 334{ 335 sptr<WindowOption> option = new WindowOption(); 336 option->SetWindowType(WindowType::WINDOW_TYPE_APP_COMPONENT); 337 sptr<WindowImpl> window = new WindowImpl(option); 338 std::shared_ptr<MMI::KeyEvent> keyEvent = std::make_shared<MockKeyEvent>(); 339 EXPECT_CALL(m->Mock(), DispatchKeyEvent(_, _)); 340 window->ConsumeKeyEvent(keyEvent); 341 window->property_->type_ = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW; 342 window->uiContent_ = std::make_unique<Ace::UIContentMocker>(); 343 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get()); 344 EXPECT_CALL(*content, ProcessKeyEvent(_, _)); 345 window->ConsumeKeyEvent(keyEvent); 346 347 window->inputEventConsumer_.reset(new MockInputEventConsumer); 348 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()), 349 OnInputEvent(keyEvent)); 350 window->ConsumeKeyEvent(keyEvent); 351 352 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_BACK); 353 keyEvent->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP); 354 window->inputEventConsumer_ = nullptr; 355 EXPECT_CALL(*content, ProcessBackPressed()); 356 window->ConsumeKeyEvent(keyEvent); 357} 358 359/* 360 * @tc.name: ConsumePointerEvent 361 * @tc.desc: ConsumePointerEvent test 362 * @tc.type: FUNC 363 */ 364HWTEST_F(WindowImplTest3, ConsumePointerEvent, Function | SmallTest | Level3) 365{ 366 sptr<WindowOption> option = new WindowOption(); 367 option->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT); 368 sptr<WindowImpl> window = new WindowImpl(option); 369 Rect rect{ 0, 0, 10u, 10u }; 370 window->property_->SetWindowRect(rect); 371 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>(); 372 MMI::PointerEvent::PointerItem item; 373 pointerEvent->SetPointerId(0); 374 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN); 375 window->ConsumePointerEvent(pointerEvent); 376 377 item.SetPointerId(0); 378 item.SetDisplayX(15); // 15 : position x 379 item.SetDisplayY(15); // 15 : position y 380 pointerEvent->AddPointerItem(item); 381 window->ConsumePointerEvent(pointerEvent); 382 383 item.SetDisplayX(5); // 5 : position x 384 item.SetDisplayY(5); // 5 : position y 385 pointerEvent->UpdatePointerItem(0, item); 386 EXPECT_CALL(m->Mock(), ProcessPointDown(_, _)); 387 window->ConsumePointerEvent(pointerEvent); 388} 389 390/* 391 * @tc.name: HandleModeChangeHotZones 392 * @tc.desc: HandleModeChangeHotZones test 393 * @tc.type: FUNC 394 */ 395HWTEST_F(WindowImplTest3, HandleModeChangeHotZones, Function | SmallTest | Level3) 396{ 397 sptr<WindowOption> option = new WindowOption(); 398 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 399 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 400 sptr<WindowImpl> window = new WindowImpl(option); 401 window->HandleModeChangeHotZones(0, 0); 402 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 403 EXPECT_CALL(m->Mock(), GetModeChangeHotZones(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING)); 404 window->HandleModeChangeHotZones(0, 0); 405 EXPECT_CALL(m->Mock(), GetModeChangeHotZones(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 406 window->HandleModeChangeHotZones(0, 0); 407} 408 409/* 410 * @tc.name: UpdatePointerEventForStretchableWindow 411 * @tc.desc: UpdatePointerEventForStretchableWindow test 412 * @tc.type: FUNC 413 */ 414HWTEST_F(WindowImplTest3, UpdatePointerEventForStretchableWindow, Function | SmallTest | Level3) 415{ 416 sptr<WindowOption> option = new WindowOption(); 417 sptr<WindowImpl> window = new WindowImpl(option); 418 window->property_->SetWindowRect(Rect{ 0, 0, 10, 10 }); 419 window->property_->SetOriginRect(Rect{ 0, 0, 100, 100 }); 420 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>(); 421 MMI::PointerEvent::PointerItem item; 422 ASSERT_FALSE(pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item)); 423 window->UpdatePointerEventForStretchableWindow(pointerEvent); 424 pointerEvent->SetPointerId(0); 425 item.SetPointerId(0); 426 item.SetDisplayX(5); // 5 : position x 427 item.SetDisplayY(5); // 5 : position y 428 pointerEvent->AddPointerItem(item); 429 window->UpdatePointerEventForStretchableWindow(pointerEvent); 430 ASSERT_TRUE(pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item)); 431 ASSERT_EQ(50, item.GetDisplayX()); 432 ASSERT_EQ(50, item.GetDisplayY()); 433} 434 435/** 436 * @tc.name: MoveDrag 437 * @tc.desc: StartMove | ReadyToMoveOrDragWindow | EndMoveOrDragWindow test 438 * @tc.type: FUNC 439 */ 440HWTEST_F(WindowImplTest3, MoveDrag, Function | SmallTest | Level3) 441{ 442 sptr<WindowOption> option = new WindowOption(); 443 option->SetWindowName("MoveDrag"); 444 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 445 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 446 sptr<WindowImpl> window = new WindowImpl(option); 447 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 448 window->RestoreSplitWindowMode(0u); 449 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 450 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 451 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 452 453 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 454 window->Show(); 455 window->moveDragProperty_->startDragFlag_ = false; 456 window->moveDragProperty_->pointEventStarted_ = true; 457 window->StartMove(); 458 window->moveDragProperty_->pointEventStarted_ = false; 459 window->StartMove(); 460 461 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>(); 462 MMI::PointerEvent::PointerItem item; 463 pointerEvent->SetTargetDisplayId(0); 464 item.SetDisplayX(10000); 465 item.SetDisplayY(10000); 466 467 window->moveDragProperty_->pointEventStarted_ = true; 468 window->ReadyToMoveOrDragWindow(pointerEvent, item); 469 window->moveDragProperty_->startMoveFlag_ = true; 470 window->moveDragProperty_->startDragFlag_ = true; 471 EXPECT_CALL(m->Mock(), ProcessPointUp(_)).Times(2); 472 window->EndMoveOrDragWindow(uint32_t(), uint32_t(), 473 window->moveDragProperty_->startPointerId_, window->moveDragProperty_->sourceType_); 474 475 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 476 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 477} 478 479/* 480 * @tc.name: TransferPointerEvent 481 * @tc.desc: TransferPointerEvent test 482 * @tc.type: FUNC 483 */ 484HWTEST_F(WindowImplTest3, TransferPointerEvent, Function | SmallTest | Level3) 485{ 486 sptr<WindowOption> option = new WindowOption(); 487 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 488 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 489 sptr<WindowImpl> window = new WindowImpl(option); 490 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>(); 491 window->windowSystemConfig_.isStretchable_ = true; 492 window->TransferPointerEvent(pointerEvent); 493 window->windowSystemConfig_.isStretchable_ = false; 494 window->TransferPointerEvent(pointerEvent); 495 window->uiContent_ = std::make_unique<Ace::UIContentMocker>(); 496 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get()); 497 EXPECT_CALL(*content, ProcessPointerEvent(_)); 498 window->TransferPointerEvent(pointerEvent); 499 500 window->inputEventConsumer_.reset(new MockInputEventConsumer); 501 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()), 502 OnInputEvent(pointerEvent)); 503 window->TransferPointerEvent(pointerEvent); 504} 505 506/* 507 * @tc.name: UpdateConfiguration 508 * @tc.desc: UpdateConfiguration test 509 * @tc.type: FUNC 510 */ 511HWTEST_F(WindowImplTest3, UpdateConfiguration, Function | SmallTest | Level3) 512{ 513 sptr<WindowOption> option = new WindowOption(); 514 option->SetWindowName("UpdateConfiguration"); 515 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 516 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 517 sptr<WindowImpl> window = new WindowImpl(option); 518 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 519 window->RestoreSplitWindowMode(0u); 520 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 521 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 522 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 523 524 option = new WindowOption(); 525 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); 526 option->SetWindowName("subwindow"); 527 sptr<WindowImpl> subWindow = new WindowImpl(option); 528 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 529 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 530 ASSERT_EQ(WMError::WM_OK, subWindow->Create(window->GetWindowId())); 531 std::shared_ptr<AppExecFwk::Configuration> configuration; 532 window->UpdateConfiguration(configuration); 533 534 window->uiContent_ = std::make_unique<Ace::UIContentMocker>(); 535 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get()); 536 subWindow->uiContent_ = std::make_unique<Ace::UIContentMocker>(); 537 Ace::UIContentMocker* subContent = reinterpret_cast<Ace::UIContentMocker*>(subWindow->uiContent_.get()); 538 EXPECT_CALL(*content, UpdateConfiguration(_)); 539 EXPECT_CALL(*subContent, UpdateConfiguration(_)); 540 window->UpdateConfiguration(configuration); 541 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 542 EXPECT_CALL(*content, Destroy()); 543 EXPECT_CALL(*subContent, Destroy()); 544 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 545} 546 547/* 548 * @tc.name: UpdateWindowState 549 * @tc.desc: UpdateWindowState test 550 * @tc.type: FUNC 551 */ 552HWTEST_F(WindowImplTest3, UpdateWindowState, Function | SmallTest | Level3) 553{ 554 sptr<WindowOption> option = new WindowOption(); 555 option->SetWindowName("UpdateWindowState"); 556 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 557 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 558 sptr<WindowImpl> window = new WindowImpl(option); 559 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 560 window->RestoreSplitWindowMode(0u); 561 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 562 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 563 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 564 565 window->UpdateWindowState(WindowState::STATE_FROZEN); 566 window->UpdateWindowState(WindowState::STATE_UNFROZEN); 567 window->UpdateWindowState(WindowState::STATE_SHOWN); 568 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 569 window->UpdateWindowState(WindowState::STATE_HIDDEN); 570 window->UpdateWindowState(WindowState::STATE_INITIAL); 571 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 572 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 573} 574 575/* 576 * @tc.name: RestoreSplitWindowMode 577 * @tc.desc: RestoreSplitWindowMode test 578 * @tc.type: FUNC 579 */ 580HWTEST_F(WindowImplTest3, RestoreSplitWindowMode, Function | SmallTest | Level3) 581{ 582 sptr<WindowOption> option = new WindowOption(); 583 option->SetWindowName("RestoreSplitWindowMode"); 584 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 585 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 586 sptr<WindowImpl> window = new WindowImpl(option); 587 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 588 window->RestoreSplitWindowMode(0u); 589 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 590 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 591 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 592 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_SPLIT_PRIMARY)); 593 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_SPLIT_SECONDARY)); 594 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_UNDEFINED)); 595 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 596 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 597} 598 599/* 600 * @tc.name: IsFocused 601 * @tc.desc: IsFocused test 602 * @tc.type: FUNC 603 */ 604HWTEST_F(WindowImplTest3, IsFocused, Function | SmallTest | Level3) 605{ 606 sptr<WindowOption> option = new WindowOption(); 607 option->SetWindowName("IsFocused"); 608 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 609 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 610 sptr<WindowImpl> window = new WindowImpl(option); 611 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 612 613 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 614 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 615 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 616 617 window->UpdateFocusStatus(false); 618 ASSERT_FALSE(window->IsFocused()); 619 window->UpdateFocusStatus(true); 620 ASSERT_TRUE(window->IsFocused()); 621 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 622 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 623} 624 625/* 626 * @tc.name: UpdateSubWindowStateAndNotify 627 * @tc.desc: update subwindow state 628 * @tc.type: FUNC 629 */ 630HWTEST_F(WindowImplTest3, UpdateSubWindowStateAndNotify, Function | SmallTest | Level3) 631{ 632 sptr<WindowOption> option = new WindowOption(); 633 option->SetWindowName("main"); 634 sptr<WindowImpl> mainWindow = new WindowImpl(option); 635 636 ASSERT_EQ(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID)); 637 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId())); 638 639 option = new WindowOption(); 640 option->SetWindowName("sub"); 641 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); 642 sptr<WindowImpl> subWindow = new WindowImpl(option); 643 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 644 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 645 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId())); 646 647 // main window hide 648 mainWindow->state_ = WindowState::STATE_HIDDEN; 649 subWindow->state_ = WindowState::STATE_SHOWN; 650 subWindow->subWindowState_ = WindowState::STATE_SHOWN; 651 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId()); 652 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN); 653 654 // main window show 655 mainWindow->state_ = WindowState::STATE_SHOWN; 656 subWindow->state_ = WindowState::STATE_SHOWN; 657 subWindow->subWindowState_ = WindowState::STATE_HIDDEN; 658 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId()); 659 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_SHOWN); 660 661 subWindow->state_ = WindowState::STATE_HIDDEN; 662 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId()); 663 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN); 664 665 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 666 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy()); 667} 668 669/* 670 * @tc.name: UpdateWindowStateWhenHide 671 * @tc.desc: UpdateWindowStateWhenHide test 672 * @tc.type: FUNC 673 */ 674HWTEST_F(WindowImplTest3, UpdateWindowStateWhenHide, Function | SmallTest | Level3) 675{ 676 sptr<WindowOption> option = new WindowOption(); 677 option->SetWindowName("main"); 678 sptr<WindowImpl> mainWindow = new WindowImpl(option); 679 ASSERT_EQ(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID)); 680 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateWindowStateWhenHide()); 681 682 option = new WindowOption(); 683 option->SetWindowName("sub"); 684 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); 685 sptr<WindowImpl> subWindow = new WindowImpl(option); 686 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 687 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 688 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId())); 689 subWindow->subWindowState_ = WindowState::STATE_SHOWN; 690 subWindow->UpdateWindowStateWhenHide(); 691 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN); 692 subWindow->subWindowState_ = WindowState::STATE_HIDDEN; 693 subWindow->UpdateWindowStateWhenHide(); 694 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN); 695 696 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 697 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy()); 698 ASSERT_EQ(WMError::WM_OK, subWindow->Destroy()); 699} 700 701/* 702 * @tc.name: UpdateWindowStateWhenShow 703 * @tc.desc: UpdateWindowStateWhenShow test 704 * @tc.type: FUNC 705 */ 706HWTEST_F(WindowImplTest3, UpdateWindowStateWhenShow, Function | SmallTest | Level3) 707{ 708 sptr<WindowOption> option = new WindowOption(); 709 option->SetWindowName("main"); 710 sptr<WindowImpl> mainWindow = new WindowImpl(option); 711 if (mainWindow->Create(INVALID_WINDOW_ID) != WMError::WM_OK) { 712 ASSERT_NE(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID)); 713 } 714 715 716 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateWindowStateWhenShow()); 717 718 option = new WindowOption(); 719 option->SetWindowName("sub"); 720 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); 721 sptr<WindowImpl> subWindow = new WindowImpl(option); 722 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 723 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 724 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId())); 725 ASSERT_EQ(WmErrorCode::WM_OK, subWindow->UpdateWindowStateWhenShow()); 726 727 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 728 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy()); 729} 730 731/* 732 * @tc.name: RaiseToAppTop 733 * @tc.desc: RaiseToAppTop test 734 * @tc.type: FUNC 735 */ 736HWTEST_F(WindowImplTest3, RaiseToAppTop, Function | SmallTest | Level3) 737{ 738 sptr<WindowOption> option = new WindowOption(); 739 option->parentId_ = INVALID_WINDOW_ID; 740 sptr<WindowImpl> window = new WindowImpl(option); 741 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->RaiseToAppTop()); 742 743 window->SetWindowState(WindowState::STATE_CREATED); 744 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARENT, window->RaiseToAppTop()); 745 746 window->property_->parentId_ = 100000; 747 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 748 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->RaiseToAppTop()); 749 750 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); 751 window->state_ = WindowState::STATE_HIDDEN; 752 ASSERT_EQ(WMError::WM_DO_NOTHING, window->RaiseToAppTop()); 753 754 window->state_ = WindowState::STATE_SHOWN; 755 EXPECT_CALL(m->Mock(), RaiseToAppTop(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 756 ASSERT_EQ(WMError::WM_OK, window->RaiseToAppTop()); 757 758 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 759 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 760} 761 762 /* 763 * @tc.name: UpdateDecorEnable 764 * @tc.desc: UpdateDecorEnable test 765 * @tc.type: FUNC 766 */ 767HWTEST_F(WindowImplTest3, UpdateDecorEnable, Function | SmallTest | Level3) 768{ 769 sptr<WindowOption> option = new WindowOption(); 770 sptr<WindowImpl> window = new WindowImpl(option); 771 window->property_->mode_ = WindowMode::WINDOW_MODE_FULLSCREEN; 772 window->property_->type_ = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW; 773 window->windowSystemConfig_.isSystemDecorEnable_ = true; 774 window->windowSystemConfig_.decorModeSupportInfo_ = WINDOW_MODE_SUPPORT_FLOATING; 775 window->uiContent_ = std::make_unique<Ace::UIContentMocker>(); 776 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get()); 777 sptr<MockWindowChangeListener> listener = new MockWindowChangeListener; 778 window->RegisterWindowChangeListener(sptr<IWindowChangeListener>(listener)); 779 780 EXPECT_CALL(*content, UpdateWindowMode(_, _)); 781 EXPECT_CALL(*listener, OnModeChange(_, _)); 782 window->UpdateDecorEnable(true); 783 ASSERT_TRUE(window->IsDecorEnable()); 784 ASSERT_FALSE(window->property_->GetDecorEnable()); 785 window->windowSystemConfig_.decorModeSupportInfo_ = WINDOW_MODE_SUPPORT_ALL; 786 window->UpdateDecorEnable(); 787 ASSERT_TRUE(window->IsDecorEnable()); 788 ASSERT_TRUE(window->property_->GetDecorEnable()); 789 window->property_->type_ = WindowType::WINDOW_TYPE_FLOAT; 790 window->UpdateDecorEnable(); 791 ASSERT_FALSE(window->IsDecorEnable()); 792 ASSERT_FALSE(window->property_->GetDecorEnable()); 793 window->UnregisterWindowChangeListener(sptr<IWindowChangeListener>(listener)); 794 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 795} 796 797/** 798 * @tc.name: Find01 799 * @tc.desc: Find one exit window 800 * @tc.type: FUNC 801 */ 802HWTEST_F(WindowImplTest3, Find01, Function | SmallTest | Level2) 803{ 804 sptr<WindowOption> option = new WindowOption(); 805 option->SetWindowName("Find01"); 806 sptr<WindowImpl> window = new WindowImpl(option); 807 ASSERT_EQ(nullptr, WindowImpl::Find("Find01")); 808 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 809} 810 811/** 812 * @tc.name: Find02 813 * @tc.desc: Find one no exit window 814 * @tc.type: FUNC 815 */ 816HWTEST_F(WindowImplTest3, Find02, Function | SmallTest | Level2) 817{ 818 ASSERT_EQ(nullptr, WindowImpl::Find("Find02")); 819} 820 821/** 822 * @tc.name: Find03 823 * @tc.desc: Find window with empty name 824 * @tc.type: FUNC 825 */ 826HWTEST_F(WindowImplTest3, Find03, Function | SmallTest | Level2) 827{ 828 ASSERT_EQ(nullptr, WindowImpl::Find("")); 829} 830 831/** 832 * @tc.name: FindWindowById02 833 * @tc.desc: Find one top window 834 * @tc.type: FUNC 835 */ 836HWTEST_F(WindowImplTest3, FindWindowById02, Function | SmallTest | Level2) 837{ 838 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 839 sptr<WindowOption> option = new WindowOption(); 840 option->SetWindowName("FindWindowById02"); 841 sptr<WindowImpl> window = new WindowImpl(option); 842 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 843 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 844 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 845 846 ASSERT_NE(nullptr, window->FindWindowById(window->property_->GetWindowId())); 847 848 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 849 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 850} 851 852/** 853 * @tc.name: FindWindowById03 854 * @tc.desc: Find one no exit window 855 * @tc.type: FUNC 856 */ 857HWTEST_F(WindowImplTest3, FindWindowById03, Function | SmallTest | Level2) 858{ 859 ASSERT_EQ(nullptr, WindowImpl::FindWindowById(0)); 860} 861 862/** 863 * @tc.name: GetTopWindowWithId02 864 * @tc.desc: Not get topwindow 865 * @tc.type: FUNC 866 */ 867HWTEST_F(WindowImplTest3, GetTopWindowWithId02, Function | SmallTest | Level2) 868{ 869 ASSERT_EQ(nullptr, WindowImpl::GetTopWindowWithId(0)); 870} 871 872/** 873 * @tc.name: UpdateConfigurationForAll01 874 * @tc.desc: UpdateConfigurationForAll01 Test 875 * @tc.type: FUNC 876 */ 877HWTEST_F(WindowImplTest3, UpdateConfigurationForAll01, Function | SmallTest | Level2) 878{ 879 sptr<WindowOption> option = new WindowOption(); 880 sptr<WindowImpl> window = new WindowImpl(option); 881 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 882 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 883 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 884 std::shared_ptr<AppExecFwk::Configuration> configuration; 885 sptr<Window>(window)->UpdateConfigurationForAll(configuration); 886 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 887 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 888} 889 890/* 891 * @tc.name: GetSurfaceNode01 892 * @tc.desc: GetSurfaceNode01 Test 893 * @tc.type: FUNC 894 */ 895HWTEST_F(WindowImplTest3, GetSurfaceNode01, Function | SmallTest | Level3) 896{ 897 sptr<WindowOption> option = new WindowOption(); 898 sptr<WindowImpl> window = new WindowImpl(option); 899 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 900 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 901 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 902 ASSERT_NE(nullptr, sptr<Window>(window)->GetSurfaceNode()); 903 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 904 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 905} 906 907/** 908 * @tc.name: GetRequestRect 909 * @tc.desc: get subwindow 910 * @tc.type: FUNC 911 */ 912HWTEST_F(WindowImplTest3, GetRequestRect, Function | SmallTest | Level2) 913{ 914 sptr<WindowOption> option = new WindowOption(); 915 sptr<WindowImpl> window = new WindowImpl(option); 916 Rect a{0, 0, 0, 0}; 917 ASSERT_EQ(a, window->GetRequestRect()); 918} 919 920/** 921 * @tc.name: GetAlpha 922 * @tc.desc: GetAlpha Test 923 * @tc.type: FUNC 924 */ 925HWTEST_F(WindowImplTest3, GetAlpha, Function | SmallTest | Level2) 926{ 927 sptr<WindowOption> option = new WindowOption(); 928 sptr<WindowImpl> window = new WindowImpl(option); 929 ASSERT_EQ(1.0f, window->GetAlpha()); 930} 931 932/** 933 * @tc.name: GetWindowState 934 * @tc.desc: GetWindowState Test 935 * @tc.type: FUNC 936 */ 937HWTEST_F(WindowImplTest3, GetWindowState, Function | SmallTest | Level2) 938{ 939 sptr<WindowOption> option = new WindowOption(); 940 sptr<WindowImpl> window = new WindowImpl(option); 941 ASSERT_EQ(WindowState::STATE_INITIAL, window->GetWindowState()); 942} 943 944/** 945 * @tc.name: SetFocusable03 946 * @tc.desc: SetFocusable Test 947 * @tc.type: FUNC 948 */ 949HWTEST_F(WindowImplTest3, SetFocusable03, Function | SmallTest | Level2) 950{ 951 sptr<WindowOption> option = new WindowOption(); 952 sptr<WindowImpl> window = new WindowImpl(option); 953 WMError err = window->SetFocusable(false); 954 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, err); 955} 956 957/** 958 * @tc.name: SetWindowType05 959 * @tc.desc: SetWindowType Test 960 * @tc.type: FUNC 961 */ 962HWTEST_F(WindowImplTest3, SetWindowType05, Function | SmallTest | Level2) 963{ 964 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 965 sptr<WindowOption> option = new WindowOption(); 966 option->SetWindowName("SetWindowType05"); 967 sptr<WindowImpl> window = new WindowImpl(option); 968 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 969 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 970 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 971 ASSERT_EQ(WMError::WM_OK, window->SetWindowType(WindowType::APP_WINDOW_BASE)); 972 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 973 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 974} 975 976/** 977 * @tc.name: SetAlpha01 978 * @tc.desc: SetAlpha Test 979 * @tc.type: FUNC 980 */ 981HWTEST_F(WindowImplTest3, SetAlpha01, Function | SmallTest | Level2) 982{ 983 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 984 sptr<WindowOption> option = new WindowOption(); 985 option->SetWindowName("SetAlpha01"); 986 sptr<WindowImpl> window = new WindowImpl(option); 987 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 988 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 989 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 990 ASSERT_EQ(WMError::WM_OK, window->SetAlpha(1.0f)); 991 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 992 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 993} 994 995/* 996 * @tc.name: CreateWindowImpl 997 * @tc.desc: CreateSurfaceNode with different type 998 * @tc.type: FUNC 999 */ 1000HWTEST_F(WindowImplTest3, CreateWindowImpl, Function | SmallTest | Level3) 1001{ 1002 sptr<WindowOption> option = new WindowOption(); 1003 option->SetWindowName("CreateSurfaceNode"); 1004 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1005 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 1006 option->SetWindowRect({ 1, 1, 1, 1 }); 1007 option->SetBundleName("OK"); 1008 ASSERT_NE(option, nullptr); 1009 sptr<WindowImpl> window = new WindowImpl(option); 1010 ASSERT_NE(window, nullptr); 1011 1012 sptr<WindowOption> option1 = new WindowOption(); 1013 option1->SetWindowName("CreateSurfaceNode1"); 1014 option1->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1015 option1->SetWindowType(WindowType::WINDOW_TYPE_BOOT_ANIMATION); 1016 option1->SetWindowRect({ 1, 1, 1, 1 }); 1017 ASSERT_NE(option1, nullptr); 1018 sptr<WindowImpl> window1 = new WindowImpl(option1); 1019 ASSERT_NE(window1, nullptr); 1020 1021 sptr<WindowOption> option2 = new WindowOption(); 1022 option2->SetWindowName("CreateSurfaceNode2"); 1023 option2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1024 option2->SetWindowType(WindowType::WINDOW_TYPE_POINTER); 1025 option2->SetWindowRect({ 1, 1, 1, 1 }); 1026 ASSERT_NE(option2, nullptr); 1027 sptr<WindowImpl> window2 = new WindowImpl(option2); 1028 ASSERT_NE(window2, nullptr); 1029 1030 sptr<WindowOption> option3 = new WindowOption(); 1031 option3->SetWindowName("CreateSurfaceNode3"); 1032 option3->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1033 option3->SetWindowType(WindowType::WINDOW_TYPE_FREEZE_DISPLAY); 1034 option3->SetWindowRect({ 1, 1, 1, 1 }); 1035 ASSERT_NE(option3, nullptr); 1036 sptr<WindowImpl> window3 = new WindowImpl(option3); 1037 ASSERT_NE(window3, nullptr); 1038 1039 sptr<WindowOption> option4 = new WindowOption(); 1040 option4->SetWindowName("CreateSurfaceNode4"); 1041 option4->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1042 option4->SetWindowType(WindowType::WINDOW_TYPE_DIALOG); 1043 option4->SetWindowRect({ 1, 1, 1, 1 }); 1044 ASSERT_NE(option4, nullptr); 1045 sptr<WindowImpl> window4 = new WindowImpl(option4); 1046 ASSERT_NE(window4, nullptr); 1047 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1048 ASSERT_EQ(WMError::WM_OK, window1->Destroy()); 1049 ASSERT_EQ(WMError::WM_OK, window2->Destroy()); 1050 ASSERT_EQ(WMError::WM_OK, window3->Destroy()); 1051 ASSERT_EQ(WMError::WM_OK, window4->Destroy()); 1052} 1053 1054/* 1055 * @tc.name: Create 1056 * @tc.desc: Create 1057 * @tc.type: FUNC 1058 */ 1059HWTEST_F(WindowImplTest3, Create, Function | SmallTest | Level3) 1060{ 1061 sptr<WindowOption> option = new WindowOption(); 1062 option->SetWindowName("CreateSurfaceNode5"); 1063 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1064 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 1065 option->SetWindowRect({ 1, 1, 1, 1 }); 1066 option->SetBundleName("OK"); 1067 ASSERT_NE(option, nullptr); 1068 sptr<WindowImpl> window = new WindowImpl(option); 1069 ASSERT_NE(window, nullptr); 1070 1071 WMError res = window->Create(INVALID_WINDOW_ID); 1072 ASSERT_EQ(WMError::WM_OK, res); 1073 1074 sptr<WindowImpl> window1 = new WindowImpl(option); // the same name 1075 ASSERT_NE(window, nullptr); 1076 res = window1->Create(INVALID_WINDOW_ID); 1077 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res); 1078 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1079 ASSERT_EQ(WMError::WM_OK, window1->Destroy()); 1080} 1081 1082/* 1083 * @tc.name: Create1 1084 * @tc.desc: Create WindowCreateCheck 1085 * @tc.type: FUNC 1086 */ 1087HWTEST_F(WindowImplTest3, Create1, Function | SmallTest | Level3) 1088{ 1089 sptr<WindowOption> option = new WindowOption(); 1090 option->SetWindowName("WindowCreateCheck"); 1091 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1092 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA); 1093 option->SetWindowRect({ 1, 1, 1, 1 }); 1094 option->SetBundleName("OK"); 1095 ASSERT_NE(option, nullptr); 1096 sptr<WindowImpl> window = new WindowImpl(option); 1097 ASSERT_NE(window, nullptr); 1098 1099 WMError res = window->Create(INVALID_WINDOW_ID); 1100 ASSERT_EQ(WMError::WM_OK, res); 1101 1102 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE); 1103 sptr<WindowImpl> window1 = new WindowImpl(option); 1104 ASSERT_NE(window1, nullptr); 1105 res = window1->Create(INVALID_WINDOW_ID); 1106 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res); 1107 1108 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE); 1109 sptr<WindowImpl> window2 = new WindowImpl(option); 1110 ASSERT_NE(window2, nullptr); 1111 res = window1->Create(INVALID_WINDOW_ID); 1112 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res); 1113 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1114 ASSERT_EQ(WMError::WM_OK, window1->Destroy()); 1115 ASSERT_EQ(WMError::WM_OK, window2->Destroy()); 1116} 1117 1118/* 1119 * @tc.name: Create2 1120 * @tc.desc: Create WindowCreateCheck 1121 * @tc.type: FUNC 1122 */ 1123HWTEST_F(WindowImplTest3, Create2, Function | SmallTest | Level3) 1124{ 1125 sptr<WindowOption> option = new WindowOption(); 1126 option->SetWindowName("WindowCreateCheck1"); 1127 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1128 option->SetWindowType(WindowType::WINDOW_TYPE_APP_COMPONENT); 1129 option->SetWindowRect({ 1, 1, 1, 1 }); 1130 option->SetBundleName("OK"); 1131 ASSERT_NE(option, nullptr); 1132 sptr<WindowImpl> window = new WindowImpl(option); 1133 ASSERT_NE(window, nullptr); 1134 1135 WMError res = window->Create(1); 1136 ASSERT_EQ(WMError::WM_OK, res); 1137 1138 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 1139 sptr<WindowImpl> window1 = new WindowImpl(option); 1140 ASSERT_NE(window1, nullptr); 1141 res = window1->Create(1); 1142 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res); 1143 1144 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE); 1145 sptr<WindowImpl> window2 = new WindowImpl(option); 1146 ASSERT_NE(window2, nullptr); 1147 res = window2->Create(1); 1148 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res); 1149 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1150 ASSERT_EQ(WMError::WM_OK, window1->Destroy()); 1151 ASSERT_EQ(WMError::WM_OK, window2->Destroy()); 1152} 1153 1154/* 1155 * @tc.name: GetTopWindowWithId 1156 * @tc.desc: CreateSurfaceNode with different type 1157 * @tc.type: FUNC 1158 */ 1159HWTEST_F(WindowImplTest3, GetTopWindowWithId, Function | SmallTest | Level3) 1160{ 1161 sptr<WindowOption> option = new WindowOption(); 1162 option->SetWindowName("GetTopWindowWithId"); 1163 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1164 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 1165 option->SetWindowRect({ 1, 1, 1, 1 }); 1166 option->SetBundleName("OK"); 1167 ASSERT_NE(option, nullptr); 1168 sptr<WindowImpl> window = new WindowImpl(option); 1169 ASSERT_NE(window, nullptr); 1170 sptr<Window> topWindow = window->GetTopWindowWithId(INVALID_WINDOW_ID); 1171 ASSERT_EQ(topWindow, nullptr); 1172 1173 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1174} 1175 1176/** 1177 * @tc.name: NotifyForegroundInteractiveStatus 1178 * @tc.desc: NotifyForegroundInteractiveStatus Test 1179 * @tc.type: FUNC 1180 */ 1181HWTEST_F(WindowImplTest3, NotifyForegroundInteractiveStatus, Function | SmallTest | Level2) 1182{ 1183 sptr<WindowOption> option = new WindowOption(); 1184 ASSERT_NE(option, nullptr); 1185 sptr<WindowImpl> window = new WindowImpl(option); 1186 ASSERT_NE(window, nullptr); 1187 bool interactive = false; 1188 window->NotifyForegroundInteractiveStatus(interactive); 1189 window->SetWindowState(WindowState::STATE_DESTROYED); 1190 interactive = true; 1191 window->NotifyForegroundInteractiveStatus(interactive); 1192 ASSERT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState()); 1193} 1194 1195/* 1196 * @tc.name: GetTopWindowWithContext 1197 * @tc.desc: GetTopWindowWithContexttest01 1198 * @tc.type: FUNC 1199 */ 1200HWTEST_F(WindowImplTest3, GetTopWindowWithContext01, Function | SmallTest | Level3) 1201{ 1202 sptr<WindowOption> option = new WindowOption(); 1203 option->SetWindowName("GetTopWindowWithContext01"); 1204 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1205 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 1206 option->SetWindowRect({ 1, 1, 1, 1 }); 1207 option->SetBundleName("OK"); 1208 ASSERT_NE(option, nullptr); 1209 sptr<WindowImpl> window = new WindowImpl(option); 1210 ASSERT_NE(window, nullptr); 1211 std::shared_ptr<AbilityRuntime::Context> context; 1212 ASSERT_EQ(nullptr, sptr<Window>(window)->GetTopWindowWithContext(context)); 1213 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1214} 1215 1216/* 1217 * @tc.name: GetSubWindow 1218 * @tc.desc: GetSubWindowtest02 1219 * @tc.type: FUNC 1220 */ 1221HWTEST_F(WindowImplTest3, GetSubWindowtext02, Function | SmallTest | Level3) 1222{ 1223 sptr<WindowOption> option = new WindowOption(); 1224 option->SetWindowName("GetSubWindowtest02"); 1225 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1226 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 1227 option->SetWindowRect({ 1, 1, 1, 1 }); 1228 option->SetBundleName("OK"); 1229 ASSERT_NE(option, nullptr); 1230 sptr<WindowImpl> window = new WindowImpl(option); 1231 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 1232 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 1233 ASSERT_NE(window, nullptr); 1234 auto subWindowVec = sptr<Window>(window)->GetSubWindow(window->GetWindowId()); 1235 if (subWindowVec.size() == 1) { 1236 ASSERT_EQ(1, subWindowVec.size()); 1237 } 1238 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 1239 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1240} 1241 1242/* 1243 * @tc.name: SetFloatingMaximize 1244 * @tc.desc: SetFloatingMaximize test 1245 * @tc.type: FUNC 1246 */ 1247HWTEST_F(WindowImplTest3, SetFloatingMaximize, Function | SmallTest | Level3) 1248{ 1249 sptr<WindowOption> option = new WindowOption(); 1250 option->SetWindowName("SetFloatingMaximize"); 1251 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 1252 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 1253 sptr<WindowImpl> window = new WindowImpl(option); 1254 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0)); 1255 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 1256 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 1257 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 1258 window->UpdateModeSupportInfo(0); 1259 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFloatingMaximize(true)); 1260 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1261} 1262 1263/** 1264 * @tc.name: SetAspectRatio 1265 * @tc.desc: SetAspectRatio Test 1266 * @tc.type: FUNC 1267 */ 1268HWTEST_F(WindowImplTest3, SetAspectRatio, Function | SmallTest | Level2) 1269{ 1270 sptr<WindowOption> option = new WindowOption(); 1271 option->SetWindowName("SetAspectRatio"); 1272 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1273 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 1274 ASSERT_NE(option, nullptr); 1275 sptr<WindowImpl> window = new WindowImpl(option); 1276 ASSERT_NE(window, nullptr); 1277 ASSERT_EQ(WMError::WM_OK, window->SetAspectRatio(1.1)); 1278 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE); 1279 ASSERT_EQ(WMError::WM_OK, window->SetAspectRatio(1.1)); 1280} 1281 1282/** 1283 * @tc.name: SetAspectRatio02 1284 * @tc.desc: SetAspectRatio Test 1285 * @tc.type: FUNC 1286 */ 1287HWTEST_F(WindowImplTest3, SetAspectRatio02, Function | SmallTest | Level2) 1288{ 1289 sptr<WindowOption> option = new WindowOption(); 1290 option->SetWindowName("SetAspectRatio02"); 1291 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1292 ASSERT_NE(option, nullptr); 1293 sptr<WindowImpl> window = new WindowImpl(option); 1294 ASSERT_NE(window, nullptr); 1295 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetAspectRatio(0.0)); 1296} 1297 1298/* 1299 * @tc.name: MapDialogWindowToAppIfNeeded 1300 * @tc.desc: MapDialogWindowToAppIfNeededtest 1301 * @tc.type: FUNC 1302 */ 1303HWTEST_F(WindowImplTest3, MapDialogWindowToAppIfNeededtest, Function | SmallTest | Level3) 1304{ 1305 sptr<WindowOption> option = new WindowOption(); 1306 option->SetWindowName("MapDialogWindowToAppIfNeededtest"); 1307 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1308 option->SetWindowType(WindowType::WINDOW_TYPE_DIALOG); 1309 option->SetWindowRect({ 1, 1, 1, 1 }); 1310 option->SetBundleName("OK"); 1311 ASSERT_NE(option, nullptr); 1312 sptr<WindowImpl> window = new WindowImpl(option); 1313 ASSERT_NE(window, nullptr); 1314 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 1315 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 1316 window->MapDialogWindowToAppIfNeeded(); 1317 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 1318 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1319} 1320 1321/* 1322 * @tc.name: GetConfigurationFromAbilityInfo 1323 * @tc.desc: GetConfigurationFromAbilityInfotest 1324 * @tc.type: FUNC 1325 */ 1326HWTEST_F(WindowImplTest3, GetConfigurationFromAbilityInfotest, Function | SmallTest | Level3) 1327{ 1328 sptr<WindowOption> option = new WindowOption(); 1329 option->SetWindowName("GetConfigurationFromAbilityInfotest"); 1330 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1331 option->SetWindowType(WindowType::WINDOW_TYPE_DIALOG); 1332 ASSERT_NE(option, nullptr); 1333 sptr<WindowImpl> window = new WindowImpl(option); 1334 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 1335 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 1336 ASSERT_NE(window, nullptr); 1337 window->MapDialogWindowToAppIfNeeded(); 1338 window->GetConfigurationFromAbilityInfo(); 1339 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 1340 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1341} 1342 1343/** 1344 * @tc.name: SetSnapshotSkip 1345 * @tc.desc: SetSnapshotSkip test 1346 * @tc.type: FUNC 1347 * @tc.require: issueI5MYNX 1348 */ 1349HWTEST_F(WindowImplTest3, SetSnapshotSkip, Function | SmallTest | Level3) 1350{ 1351 sptr<WindowOption> option = new WindowOption(); 1352 option->SetWindowName("SetSnapshotSkip"); 1353 sptr<WindowImpl> window = new WindowImpl(option); 1354 ASSERT_NE(nullptr, window); 1355 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 1356 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillRepeatedly(Return(WMError::WM_OK)); 1357 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSnapshotSkip(true)); 1358} 1359 1360/** 1361 * @tc.name: MaximizeFloating 1362 * @tc.desc: MaximizeFloating test 1363 * @tc.type: FUNC 1364 */ 1365HWTEST_F(WindowImplTest3, MaximizeFloating, Function | SmallTest | Level3) 1366{ 1367 std::unique_ptr<Mocker> m = std::make_unique<Mocker>(); 1368 sptr<WindowOption> option = new WindowOption(); 1369 option->SetWindowName("MaximizeFloating"); 1370 sptr<WindowImpl> window = new WindowImpl(option); 1371 window->MaximizeFloating(); 1372 ASSERT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, window->GetMode()); 1373 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK)); 1374 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 1375 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID)); 1376 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); 1377 window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1378 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 1379 window->Show(); 1380 window->MaximizeFloating(); 1381 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode()); 1382 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK)); 1383 window->Hide(); 1384 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); 1385 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 1386} 1387 1388/** 1389 * @tc.name: GetTopWindowWithId03 1390 * @tc.desc: GetTopWindowWithId test 1391 * @tc.type: FUNC 1392 */ 1393HWTEST_F(WindowImplTest3, GetTopWindowWithId03, Function | SmallTest | Level3) 1394{ 1395 sptr<WindowOption> option = new WindowOption(); 1396 option->SetWindowName("GetTopWindowWithId03"); 1397 sptr<WindowImpl> window = new WindowImpl(option); 1398 uint32_t mainWinId = 0; 1399 uint32_t windowId = 1; 1400 string winName = "test"; 1401 WindowImpl::windowMap_.insert(std::make_pair(winName, std::pair<uint32_t, sptr<Window>>(windowId, window))); 1402 1403 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _)).WillRepeatedly(Return(WMError::WM_ERROR_DEVICE_NOT_SUPPORT)); 1404 ASSERT_EQ(nullptr, window->GetTopWindowWithId(mainWinId)); 1405 1406 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _)).WillRepeatedly(DoAll( 1407 SetArgReferee<1>(windowId), 1408 Return(WMError::WM_OK) 1409 )); 1410 ASSERT_NE(nullptr, window->GetTopWindowWithId(mainWinId)); 1411 uint32_t topWinId = 1; 1412 ASSERT_EQ(WindowImpl::FindWindowById(topWinId), window->GetTopWindowWithId(mainWinId)); 1413 1414 uint32_t tempWindowId = 3; 1415 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _)).WillRepeatedly(DoAll( 1416 SetArgReferee<1>(tempWindowId), 1417 Return(WMError::WM_OK) 1418 )); 1419 ASSERT_EQ(nullptr, window->GetTopWindowWithId(mainWinId)); 1420 1421 WindowImpl::windowMap_.erase(winName); 1422} 1423 1424/** 1425 * @tc.name: GetTopWindowWithContext02 1426 * @tc.desc: GetTopWindowWithContext test 1427 * @tc.type: FUNC 1428 */ 1429HWTEST_F(WindowImplTest3, GetTopWindowWithContext02, Function | SmallTest | Level3) 1430{ 1431 sptr<WindowOption> option = new WindowOption(); 1432 option->SetWindowName("GetTopWindowWithContext02"); 1433 sptr<WindowImpl> window = new WindowImpl(option); 1434 std::shared_ptr<AbilityRuntime::Context> context; 1435 uint32_t mainWinId = INVALID_WINDOW_ID; 1436 1437 WMError ret = WMError::WM_ERROR_DEVICE_NOT_SUPPORT; 1438 ASSERT_NE(WMError::WM_OK, ret); 1439 ASSERT_EQ(INVALID_WINDOW_ID, mainWinId); 1440 ASSERT_EQ(nullptr, window->GetTopWindowWithContext(context)); 1441 ret = WMError::WM_OK; 1442 uint32_t topWinId = INVALID_WINDOW_ID; 1443 ASSERT_EQ(WindowImpl::FindWindowById(topWinId), window->GetTopWindowWithContext(context)); 1444} 1445 1446/** 1447 * @tc.name: GetSubWindow03 1448 * @tc.desc: GetSubWindowtest 1449 * @tc.type: FUNC 1450 */ 1451HWTEST_F(WindowImplTest3, GetSubWindow03, Function | SmallTest | Level3) 1452{ 1453 sptr<WindowOption> option = new WindowOption(); 1454 option->SetWindowName("GetSubWindow03"); 1455 sptr<WindowImpl> window = new WindowImpl(option); 1456 uint32_t parentId = 0; 1457 1458 ASSERT_EQ(std::vector<sptr<Window>>(), window->GetSubWindow(parentId)); 1459} 1460 1461/** 1462 * @tc.name: SetNeedDefaultAnimation 1463 * @tc.desc: SetNeedDefaultAnimation 1464 * @tc.type: FUNC 1465 */ 1466HWTEST_F(WindowImplTest3, SetNeedDefaultAnimation, Function | SmallTest | Level3) 1467{ 1468 sptr<WindowOption> option = new WindowOption(); 1469 option->SetWindowName("SetNeedDefaultAnimation"); 1470 sptr<WindowImpl> window = new WindowImpl(option); 1471 bool defaultAnimation = true; 1472 window->SetNeedDefaultAnimation(defaultAnimation); 1473 EXPECT_EQ(true, window->needDefaultAnimation_); 1474 EXPECT_EQ(WMError::WM_OK, window->SetTextFieldAvoidInfo(2.0, 3.0)); 1475} 1476} 1477} // namespace Rosen 1478} // namespace OHOS 1479