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 <regex> 18#include <pointer_event.h> 19#include <ui/rs_surface_node.h> 20 21#include "key_event.h" 22#include "mock/mock_session_stage.h" 23#include "mock/mock_window_event_channel.h" 24#include "mock/mock_pattern_detach_callback.h" 25#include "session/host/include/extension_session.h" 26#include "session/host/include/move_drag_controller.h" 27#include "session/host/include/scene_session.h" 28#include "session/host/include/session.h" 29#include "session_manager/include/scene_session_manager.h" 30#include "session_info.h" 31#include "session/screen/include/screen_session.h" 32#include "screen_session_manager_client/include/screen_session_manager_client.h" 33#include "wm_common.h" 34#include "window_manager_hilog.h" 35 36using namespace testing; 37using namespace testing::ext; 38 39namespace OHOS { 40namespace Rosen { 41namespace { 42const std::string UNDEFINED = "undefined"; 43} 44 45class WindowSessionTest3 : public testing::Test { 46public: 47 static void SetUpTestCase(); 48 static void TearDownTestCase(); 49 void SetUp() override; 50 void TearDown() override; 51 52 int32_t GetTaskCount(); 53 sptr<SceneSessionManager> ssm_; 54 55private: 56 RSSurfaceNode::SharedPtr CreateRSSurfaceNode(); 57 sptr<Session> session_ = nullptr; 58 static constexpr uint32_t WAIT_SYNC_IN_NS = 500000; 59}; 60 61void WindowSessionTest3::SetUpTestCase() 62{ 63} 64 65void WindowSessionTest3::TearDownTestCase() 66{ 67} 68 69void WindowSessionTest3::SetUp() 70{ 71 SessionInfo info; 72 info.abilityName_ = "testSession1"; 73 info.moduleName_ = "testSession2"; 74 info.bundleName_ = "testSession3"; 75 session_ = sptr<Session>::MakeSptr(info); 76 EXPECT_NE(nullptr, session_); 77 session_->surfaceNode_ = CreateRSSurfaceNode(); 78 ssm_ = sptr<SceneSessionManager>::MakeSptr(); 79 session_->SetEventHandler(ssm_->taskScheduler_->GetEventHandler(), ssm_->eventHandler_); 80 auto isScreenLockedCallback = [this]() { 81 return ssm_->IsScreenLocked(); 82 }; 83 session_->RegisterIsScreenLockedCallback(isScreenLockedCallback); 84} 85 86void WindowSessionTest3::TearDown() 87{ 88 session_ = nullptr; 89 usleep(WAIT_SYNC_IN_NS); 90} 91 92RSSurfaceNode::SharedPtr WindowSessionTest3::CreateRSSurfaceNode() 93{ 94 struct RSSurfaceNodeConfig rsSurfaceNodeConfig; 95 rsSurfaceNodeConfig.SurfaceNodeName = "WindowSessionTest3SurfaceNode"; 96 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig); 97 if (surfaceNode == nullptr) { 98 GTEST_LOG_(INFO) << "WindowSessionTest3::CreateRSSurfaceNode surfaceNode is nullptr"; 99 } 100 return surfaceNode; 101} 102 103int32_t WindowSessionTest3::GetTaskCount() 104{ 105 std::string dumpInfo = session_->handler_->GetEventRunner()->GetEventQueue()->DumpCurrentQueueSize(); 106 std::regex pattern("\\d+"); 107 std::smatch matches; 108 int32_t taskNum = 0; 109 while (std::regex_search(dumpInfo, matches, pattern)) { 110 taskNum += std::stoi(matches.str()); 111 dumpInfo = matches.suffix(); 112 } 113 return taskNum; 114} 115 116namespace { 117/** 118 * @tc.name: NotifyContextTransparent 119 * @tc.desc: NotifyContextTransparent Test 120 * @tc.type: FUNC 121 */ 122HWTEST_F(WindowSessionTest3, NotifyContextTransparent, Function | SmallTest | Level2) 123{ 124 ASSERT_NE(session_, nullptr); 125 NotifyContextTransparentFunc contextTransparentFunc = session_->contextTransparentFunc_; 126 if (contextTransparentFunc == nullptr) { 127 contextTransparentFunc = {}; 128 } 129 session_->contextTransparentFunc_ = nullptr; 130 session_->NotifyContextTransparent(); 131 132 session_->SetContextTransparentFunc(contextTransparentFunc); 133 session_->NotifyContextTransparent(); 134 session_->SetPendingSessionToBackgroundForDelegatorListener(nullptr); 135 EXPECT_EQ(WSError::WS_OK, session_->PendingSessionToBackgroundForDelegator(true)); 136} 137 138/** 139 * @tc.name: SetFocusable04 140 * @tc.desc: SetFocusable Test 141 * @tc.type: FUNC 142 */ 143HWTEST_F(WindowSessionTest3, SetFocusable04, Function | SmallTest | Level2) 144{ 145 ASSERT_NE(session_, nullptr); 146 session_->property_ = nullptr; 147 auto result = session_->SetFocusable(false); 148 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR); 149 150 session_->isFocused_ = true; 151 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 152 EXPECT_NE(session_->property_, nullptr); 153 session_->property_->SetFocusable(false); 154 155 result = session_->SetFocusable(false); 156 EXPECT_EQ(result, WSError::WS_OK); 157 EXPECT_EQ(session_->GetFocusable(), false); 158} 159 160/** 161 * @tc.name: SetSystemFocusable 162 * @tc.desc: SetSystemFocusable Test 163 * @tc.type: FUNC 164 */ 165HWTEST_F(WindowSessionTest3, SetSystemFocusable, Function | SmallTest | Level2) 166{ 167 ASSERT_NE(session_, nullptr); 168 ASSERT_EQ(session_->GetSystemFocusable(), true); 169 bool systemFocusable = false; 170 session_->SetSystemFocusable(systemFocusable); 171 ASSERT_EQ(session_->GetSystemFocusable(), systemFocusable); 172} 173 174/** 175 * @tc.name: SetFocusableOnShow 176 * @tc.desc: SetFocusableOnShow Test 177 * @tc.type: FUNC 178 */ 179HWTEST_F(WindowSessionTest3, SetFocusableOnShow, Function | SmallTest | Level2) 180{ 181 ASSERT_NE(session_, nullptr); 182 ASSERT_EQ(session_->IsFocusableOnShow(), true); 183 bool focusableOnShow = false; 184 session_->SetFocusableOnShow(focusableOnShow); 185 usleep(10000); // sleep 10ms 186 ASSERT_EQ(session_->IsFocusableOnShow(), focusableOnShow); 187} 188 189/** 190 * @tc.name: CheckFocusable 191 * @tc.desc: CheckFocusable Test 192 * @tc.type: FUNC 193 */ 194HWTEST_F(WindowSessionTest3, CheckFocusable, Function | SmallTest | Level2) 195{ 196 ASSERT_NE(session_, nullptr); 197 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 198 ASSERT_EQ(session_->CheckFocusable(), true); 199 session_->SetSystemFocusable(false); 200 ASSERT_EQ(session_->CheckFocusable(), false); 201} 202 203/** 204 * @tc.name: SetTouchable03 205 * @tc.desc: IsSessionValid() and touchable return true 206 * @tc.type: FUNC 207 */ 208HWTEST_F(WindowSessionTest3, SetTouchable03, Function | SmallTest | Level2) 209{ 210 ASSERT_NE(session_, nullptr); 211 session_->SetSessionState(SessionState::STATE_FOREGROUND); 212 session_->sessionInfo_.isSystem_ = false; 213 EXPECT_EQ(WSError::WS_OK, session_->SetTouchable(true)); 214} 215 216/** 217 * @tc.name: GetTouchable02 218 * @tc.desc: GetTouchable Test 219 * @tc.type: FUNC 220 */ 221HWTEST_F(WindowSessionTest3, GetTouchable02, Function | SmallTest | Level2) 222{ 223 ASSERT_NE(session_, nullptr); 224 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 225 ASSERT_NE(session_->property_, nullptr); 226 EXPECT_EQ(true, session_->GetTouchable()); 227 228 session_->property_ = nullptr; 229 EXPECT_EQ(true, session_->GetTouchable()); 230} 231 232/** 233 * @tc.name: UpdateDensity02 234 * @tc.desc: UpdateDensity Test 235 * @tc.type: FUNC 236 */ 237HWTEST_F(WindowSessionTest3, UpdateDensity02, Function | SmallTest | Level2) 238{ 239 ASSERT_NE(session_, nullptr); 240 session_->SetSessionState(SessionState::STATE_FOREGROUND); 241 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 242 EXPECT_NE(nullptr, mockSessionStage); 243 session_->sessionStage_ = mockSessionStage; 244 auto result = session_->UpdateDensity(); 245 EXPECT_EQ(result, WSError::WS_OK); 246} 247 248/** 249 * @tc.name: UpdateOrientation 250 * @tc.desc: UpdateOrientation Test 251 * @tc.type: FUNC 252 */ 253HWTEST_F(WindowSessionTest3, UpdateOrientation, Function | SmallTest | Level2) 254{ 255 ASSERT_NE(session_, nullptr); 256 session_->sessionInfo_.isSystem_ = true; 257 auto result = session_->UpdateOrientation(); 258 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_SESSION); 259 260 session_->sessionInfo_.isSystem_ = false; 261 session_->SetSessionState(SessionState::STATE_FOREGROUND); 262 result = session_->UpdateOrientation(); 263 EXPECT_EQ(result, WSError::WS_ERROR_NULLPTR); 264 265 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 266 EXPECT_NE(nullptr, mockSessionStage); 267 session_->sessionStage_ = mockSessionStage; 268 result = session_->UpdateOrientation(); 269 EXPECT_EQ(result, WSError::WS_OK); 270} 271 272/** 273 * @tc.name: HandleDialogBackground 274 * @tc.desc: HandleDialogBackground Test 275 * @tc.type: FUNC 276 */ 277HWTEST_F(WindowSessionTest3, HandleDialogBackground, Function | SmallTest | Level2) 278{ 279 ASSERT_NE(session_, nullptr); 280 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 281 ASSERT_NE(session_->property_, nullptr); 282 session_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END); 283 session_->HandleDialogBackground(); 284 285 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 286 sptr<Session> session01 = nullptr; 287 288 SessionInfo info; 289 info.abilityName_ = "testSession1"; 290 info.moduleName_ = "testSession2"; 291 info.bundleName_ = "testSession3"; 292 sptr<Session> session02 = sptr<Session>::MakeSptr(info); 293 sptr<Session> session03 = sptr<Session>::MakeSptr(info); 294 EXPECT_NE(session02, nullptr); 295 EXPECT_NE(session03, nullptr); 296 297 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 298 EXPECT_NE(nullptr, mockSessionStage); 299 session02->sessionStage_ = mockSessionStage; 300 session03->sessionStage_ = nullptr; 301 302 session_->dialogVec_.push_back(session01); 303 session_->dialogVec_.push_back(session02); 304 session_->dialogVec_.push_back(session03); 305 session_->HandleDialogBackground(); 306 session_->SetPendingSessionToBackgroundForDelegatorListener(nullptr); 307 EXPECT_EQ(WSError::WS_OK, session_->PendingSessionToBackgroundForDelegator(true)); 308} 309 310/** 311 * @tc.name: HandleDialogForeground 312 * @tc.desc: HandleDialogForeground Test 313 * @tc.type: FUNC 314 */ 315HWTEST_F(WindowSessionTest3, HandleDialogForeground, Function | SmallTest | Level2) 316{ 317 ASSERT_NE(session_, nullptr); 318 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 319 ASSERT_NE(session_->property_, nullptr); 320 session_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END); 321 session_->HandleDialogForeground(); 322 323 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 324 sptr<Session> session01 = nullptr; 325 326 SessionInfo info; 327 info.abilityName_ = "testSession1"; 328 info.moduleName_ = "testSession2"; 329 info.bundleName_ = "testSession3"; 330 sptr<Session> session02 = sptr<Session>::MakeSptr(info); 331 sptr<Session> session03 = sptr<Session>::MakeSptr(info); 332 EXPECT_NE(session02, nullptr); 333 EXPECT_NE(session03, nullptr); 334 335 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 336 EXPECT_NE(nullptr, mockSessionStage); 337 session02->sessionStage_ = mockSessionStage; 338 session03->sessionStage_ = nullptr; 339 340 session_->dialogVec_.push_back(session01); 341 session_->dialogVec_.push_back(session02); 342 session_->dialogVec_.push_back(session03); 343 session_->HandleDialogForeground(); 344 session_->SetPendingSessionToBackgroundForDelegatorListener(nullptr); 345 EXPECT_EQ(WSError::WS_OK, session_->PendingSessionToBackgroundForDelegator(true)); 346} 347 348/** 349 * @tc.name: SetActive 350 * @tc.desc: SetActive Test 351 * @tc.type: FUNC 352 */ 353HWTEST_F(WindowSessionTest3, SetActive, Function | SmallTest | Level2) 354{ 355 ASSERT_NE(session_, nullptr); 356 session_->SetSessionState(SessionState::STATE_CONNECT); 357 auto result = session_->SetActive(false); 358 EXPECT_EQ(result, WSError::WS_DO_NOTHING); 359} 360 361/** 362 * @tc.name: SetActive02 363 * @tc.desc: SetActive Test 364 * @tc.type: FUNC 365 */ 366HWTEST_F(WindowSessionTest3, SetActive02, Function | SmallTest | Level2) 367{ 368 ASSERT_NE(session_, nullptr); 369 session_->SetSessionState(SessionState::STATE_FOREGROUND); 370 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 371 EXPECT_NE(nullptr, mockSessionStage); 372 session_->sessionStage_ = mockSessionStage; 373 auto result = session_->SetActive(true); 374 EXPECT_EQ(result, WSError::WS_OK); 375} 376 377/** 378 * @tc.name: SetActive03 379 * @tc.desc: SetActive Test 380 * @tc.type: FUNC 381 */ 382HWTEST_F(WindowSessionTest3, SetActive03, Function | SmallTest | Level2) 383{ 384 ASSERT_NE(session_, nullptr); 385 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 386 EXPECT_NE(nullptr, mockSessionStage); 387 session_->sessionStage_ = mockSessionStage; 388 389 session_->SetSessionState(SessionState::STATE_CONNECT); 390 auto result = session_->SetActive(true); 391 EXPECT_EQ(result, WSError::WS_OK); 392 393 session_->isActive_ = true; 394 result = session_->SetActive(false); 395 EXPECT_EQ(result, WSError::WS_OK); 396 397 session_->SetSessionState(SessionState::STATE_ACTIVE); 398 session_->isActive_ = true; 399 result = session_->SetActive(false); 400 EXPECT_EQ(result, WSError::WS_OK); 401} 402 403/** 404 * @tc.name: IsTopDialog02 405 * @tc.desc: IsTopDialog Test 406 * @tc.type: FUNC 407 */ 408HWTEST_F(WindowSessionTest3, IsTopDialog02, Function | SmallTest | Level2) 409{ 410 ASSERT_NE(session_, nullptr); 411 session_->SetParentSession(nullptr); 412 EXPECT_EQ(false, session_->IsTopDialog()); 413 414 SessionInfo info; 415 info.abilityName_ = "testSession1"; 416 info.moduleName_ = "testSession2"; 417 info.bundleName_ = "testSession3"; 418 sptr<Session> parentSession = sptr<Session>::MakeSptr(info); 419 ASSERT_NE(parentSession, nullptr); 420 parentSession->dialogVec_.clear(); 421 session_->SetParentSession(parentSession); 422 auto result = session_->IsTopDialog(); 423 EXPECT_EQ(result, true); 424} 425 426/** 427 * @tc.name: IsTopDialog03 428 * @tc.desc: IsTopDialog Test 429 * @tc.type: FUNC 430 */ 431HWTEST_F(WindowSessionTest3, IsTopDialog03, Function | SmallTest | Level2) 432{ 433 ASSERT_NE(session_, nullptr); 434 session_->dialogVec_.clear(); 435 SessionInfo info; 436 info.abilityName_ = "testSession1"; 437 info.moduleName_ = "testSession2"; 438 info.bundleName_ = "testSession3"; 439 sptr<Session> dialogSession1 = sptr<Session>::MakeSptr(info); 440 sptr<Session> dialogSession2 = sptr<Session>::MakeSptr(info); 441 ASSERT_NE(dialogSession1, nullptr); 442 ASSERT_NE(dialogSession2, nullptr); 443 dialogSession1->SetParentSession(session_); 444 dialogSession2->SetParentSession(session_); 445 session_->dialogVec_.push_back(dialogSession1); 446 session_->dialogVec_.push_back(dialogSession2); 447 dialogSession1->SetSessionState(SessionState::STATE_INACTIVE); 448 dialogSession2->SetSessionState(SessionState::STATE_INACTIVE); 449 EXPECT_EQ(false, dialogSession1->IsTopDialog()); 450} 451 452/** 453 * @tc.name: PresentFocusIfPointDown 454 * @tc.desc: PresentFocusIfPointDown Test 455 * @tc.type: FUNC 456 */ 457HWTEST_F(WindowSessionTest3, PresentFocusIfPointDown, Function | SmallTest | Level2) 458{ 459 ASSERT_NE(session_, nullptr); 460 session_->isFocused_ = true; 461 session_->PresentFocusIfPointDown(); 462 463 session_->isFocused_ = false; 464 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 465 EXPECT_NE(session_->property_, nullptr); 466 session_->property_->SetFocusable(false); 467 session_->PresentFocusIfPointDown(); 468 session_->SetPendingSessionToBackgroundForDelegatorListener(nullptr); 469 EXPECT_EQ(WSError::WS_OK, session_->PendingSessionToBackgroundForDelegator(true)); 470} 471 472/** 473 * @tc.name: HandlePointDownDialog 474 * @tc.desc: HandlePointDownDialog Test 475 * @tc.type: FUNC 476 */ 477HWTEST_F(WindowSessionTest3, HandlePointDownDialog, Function | SmallTest | Level2) 478{ 479 ASSERT_NE(session_, nullptr); 480 SessionInfo info; 481 info.abilityName_ = "testSession1"; 482 info.moduleName_ = "testSession2"; 483 info.bundleName_ = "testSession3"; 484 sptr<Session> dialogSession1 = sptr<Session>::MakeSptr(info); 485 sptr<Session> dialogSession2 = sptr<Session>::MakeSptr(info); 486 sptr<Session> dialogSession3 = sptr<Session>::MakeSptr(info); 487 sptr<Session> dialogSession4 = nullptr; 488 ASSERT_NE(dialogSession1, nullptr); 489 ASSERT_NE(dialogSession2, nullptr); 490 ASSERT_NE(dialogSession3, nullptr); 491 dialogSession1->SetSessionState(SessionState::STATE_FOREGROUND); 492 dialogSession2->SetSessionState(SessionState::STATE_ACTIVE); 493 dialogSession2->SetSessionState(SessionState::STATE_INACTIVE); 494 session_->dialogVec_.push_back(dialogSession1); 495 session_->dialogVec_.push_back(dialogSession2); 496 session_->dialogVec_.push_back(dialogSession3); 497 session_->dialogVec_.push_back(dialogSession4); 498 session_->HandlePointDownDialog(); 499 session_->SetPendingSessionToBackgroundForDelegatorListener(nullptr); 500 EXPECT_EQ(WSError::WS_OK, session_->PendingSessionToBackgroundForDelegator(true)); 501} 502 503/** 504 * @tc.name: HandleSubWindowClick01 505 * @tc.desc: parentSession and property is nullptr 506 * @tc.type: FUNC 507 */ 508HWTEST_F(WindowSessionTest3, HandleSubWindowClick01, Function | SmallTest | Level2) 509{ 510 ASSERT_NE(session_, nullptr); 511 auto result = session_->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_DOWN); 512 EXPECT_EQ(result, WSError::WS_OK); 513} 514 515/** 516 * @tc.name: HandleSubWindowClick03 517 * @tc.desc: parentSession->dialogVec_ is nullptr 518 * @tc.type: FUNC 519 */ 520HWTEST_F(WindowSessionTest3, HandleSubWindowClick03, Function | SmallTest | Level2) 521{ 522 ASSERT_NE(session_, nullptr); 523 SessionInfo info; 524 info.abilityName_ = "testSession1"; 525 info.moduleName_ = "testSession2"; 526 info.bundleName_ = "testSession3"; 527 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info); 528 ASSERT_NE(dialogSession, nullptr); 529 session_->SetParentSession(dialogSession); 530 531 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 532 ASSERT_NE(session_->property_, nullptr); 533 534 auto result = session_->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_DOWN); 535 EXPECT_EQ(result, WSError::WS_OK); 536 537 result = session_->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_MOVE); 538 EXPECT_EQ(result, WSError::WS_OK); 539} 540 541/** 542 * @tc.name: TransferPointerEvent06 543 * @tc.desc: TransferPointerEvent Test 544 * @tc.type: FUNC 545 */ 546HWTEST_F(WindowSessionTest3, TransferPointerEvent06, Function | SmallTest | Level2) 547{ 548 ASSERT_NE(session_, nullptr); 549 session_->SetSessionState(SessionState::STATE_CONNECT); 550 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create(); 551 ASSERT_NE(pointerEvent, nullptr); 552 553 SessionInfo info; 554 info.abilityName_ = "testSession1"; 555 info.moduleName_ = "testSession2"; 556 info.bundleName_ = "testSession3"; 557 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info); 558 ASSERT_NE(dialogSession, nullptr); 559 dialogSession->SetSessionState(SessionState::STATE_ACTIVE); 560 session_->dialogVec_.push_back(dialogSession); 561 pointerEvent->pointerAction_ = MMI::PointerEvent::POINTER_ACTION_DOWN; 562 563 auto result = session_->TransferPointerEvent(pointerEvent); 564 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_PERMISSION); 565} 566 567/** 568 * @tc.name: TransferPointerEvent07 569 * @tc.desc: TransferPointerEvent Test 570 * @tc.type: FUNC 571 */ 572HWTEST_F(WindowSessionTest3, TransferPointerEvent07, Function | SmallTest | Level2) 573{ 574 ASSERT_NE(session_, nullptr); 575 session_->SetSessionState(SessionState::STATE_CONNECT); 576 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create(); 577 ASSERT_NE(pointerEvent, nullptr); 578 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 579 ASSERT_NE(session_->property_, nullptr); 580 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG); 581 auto result = session_->TransferPointerEvent(pointerEvent); 582 EXPECT_EQ(result, WSError::WS_ERROR_NULLPTR); 583} 584 585/** 586 * @tc.name: TransferPointerEvent08 587 * @tc.desc: TransferPointerEvent Test 588 * @tc.type: FUNC 589 */ 590HWTEST_F(WindowSessionTest3, TransferPointerEvent08, Function | SmallTest | Level2) 591{ 592 ASSERT_NE(session_, nullptr); 593 session_->SetSessionState(SessionState::STATE_CONNECT); 594 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create(); 595 ASSERT_NE(pointerEvent, nullptr); 596 597 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 598 ASSERT_NE(session_->property_, nullptr); 599 600 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG); 601 SessionInfo info; 602 info.abilityName_ = "testSession1"; 603 info.moduleName_ = "testSession2"; 604 info.bundleName_ = "testSession3"; 605 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info); 606 ASSERT_NE(dialogSession, nullptr); 607 608 session_->SetParentSession(dialogSession); 609 auto result = session_->TransferPointerEvent(pointerEvent); 610 EXPECT_EQ(result, WSError::WS_ERROR_NULLPTR); 611} 612 613/** 614 * @tc.name: TransferPointerEvent09 615 * @tc.desc: TransferPointerEvent Test 616 * @tc.type: FUNC 617 */ 618HWTEST_F(WindowSessionTest3, TransferPointerEvent09, Function | SmallTest | Level2) 619{ 620 ASSERT_NE(session_, nullptr); 621 session_->SetSessionState(SessionState::STATE_FOREGROUND); 622 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create(); 623 ASSERT_NE(pointerEvent, nullptr); 624 625 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 626 ASSERT_NE(session_->property_, nullptr); 627 628 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG); 629 SessionInfo info; 630 info.abilityName_ = "testSession1"; 631 info.moduleName_ = "testSession2"; 632 info.bundleName_ = "testSession3"; 633 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info); 634 ASSERT_NE(dialogSession, nullptr); 635 636 session_->SetParentSession(dialogSession); 637 dialogSession->dialogVec_.push_back(session_); 638 pointerEvent->pointerAction_ = MMI::PointerEvent::POINTER_ACTION_MOVE; 639 auto result = session_->TransferPointerEvent(pointerEvent); 640 EXPECT_EQ(result, WSError::WS_ERROR_NULLPTR); 641} 642 643/** 644 * @tc.name: TransferPointerEvent10 645 * @tc.desc: TransferPointerEvent Test 646 * @tc.type: FUNC 647 */ 648HWTEST_F(WindowSessionTest3, TransferPointerEvent10, Function | SmallTest | Level2) 649{ 650 ASSERT_NE(session_, nullptr); 651 session_->SetSessionState(SessionState::STATE_FOREGROUND); 652 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create(); 653 ASSERT_NE(pointerEvent, nullptr); 654 pointerEvent->pointerAction_ = MMI::PointerEvent::POINTER_ACTION_DOWN; 655 656 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 657 ASSERT_NE(session_->property_, nullptr); 658 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG); 659 660 SessionInfo info; 661 info.abilityName_ = "testSession1"; 662 info.moduleName_ = "testSession2"; 663 info.bundleName_ = "testSession3"; 664 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info); 665 sptr<Session> dialogSession2 = sptr<Session>::MakeSptr(info); 666 sptr<Session> dialogSession3 = sptr<Session>::MakeSptr(info); 667 ASSERT_NE(dialogSession, nullptr); 668 ASSERT_NE(dialogSession2, nullptr); 669 ASSERT_NE(dialogSession3, nullptr); 670 dialogSession2->SetSessionState(SessionState::STATE_FOREGROUND); 671 dialogSession3->SetSessionState(SessionState::STATE_ACTIVE); 672 dialogSession2->persistentId_ = 9; 673 session_->SetParentSession(dialogSession); 674 dialogSession->dialogVec_.push_back(dialogSession2); 675 dialogSession->dialogVec_.push_back(dialogSession3); 676 auto result = session_->TransferPointerEvent(pointerEvent); 677 EXPECT_EQ(result, WSError::WS_ERROR_NULLPTR); 678} 679 680/** 681 * @tc.name: TransferPointerEvent11 682 * @tc.desc: TransferPointerEvent Test 683 * @tc.type: FUNC 684 */ 685HWTEST_F(WindowSessionTest3, TransferPointerEvent11, Function | SmallTest | Level2) 686{ 687 ASSERT_NE(session_, nullptr); 688 session_->SetSessionState(SessionState::STATE_FOREGROUND); 689 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create(); 690 ASSERT_NE(pointerEvent, nullptr); 691 692 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 693 ASSERT_NE(session_->property_, nullptr); 694 session_->property_->SetWindowType(WindowType::APP_WINDOW_BASE); 695 696 session_->windowEventChannel_ = nullptr; 697 auto result = session_->TransferPointerEvent(pointerEvent); 698 EXPECT_EQ(result, WSError::WS_ERROR_NULLPTR); 699} 700 701/** 702 * @tc.name: TransferFocusStateEvent03 703 * @tc.desc: TransferFocusStateEvent Test 704 * @tc.type: FUNC 705 */ 706HWTEST_F(WindowSessionTest3, TransferFocusStateEvent03, Function | SmallTest | Level2) 707{ 708 ASSERT_NE(session_, nullptr); 709 session_->windowEventChannel_ = nullptr; 710 session_->sessionInfo_.isSystem_ = true; 711 EXPECT_EQ(session_->TransferFocusStateEvent(true), WSError::WS_ERROR_NULLPTR); 712} 713 714/** 715 * @tc.name: Snapshot 716 * @tc.desc: Snapshot Test 717 * @tc.type: FUNC 718 */ 719HWTEST_F(WindowSessionTest3, Snapshot, Function | SmallTest | Level2) 720{ 721 ASSERT_NE(session_, nullptr); 722 int32_t persistentId = 1424; 723 std::string bundleName = "testBundleName"; 724 session_->scenePersistence_ = sptr<ScenePersistence>::MakeSptr(bundleName, persistentId); 725 ASSERT_NE(session_->scenePersistence_, nullptr); 726 struct RSSurfaceNodeConfig config; 727 session_->surfaceNode_ = RSSurfaceNode::Create(config); 728 ASSERT_NE(session_->surfaceNode_, nullptr); 729 EXPECT_EQ(nullptr, session_->Snapshot(false, 0.0f)); 730 731 session_->bufferAvailable_ = true; 732 EXPECT_EQ(nullptr, session_->Snapshot(false, 0.0f)); 733 734 session_->surfaceNode_->bufferAvailable_ = true; 735 EXPECT_EQ(nullptr, session_->Snapshot(false, 0.0f)); 736 737 session_->surfaceNode_ = nullptr; 738 EXPECT_EQ(nullptr, session_->Snapshot(false, 0.0f)); 739} 740 741/** 742 * @tc.name: SetBufferAvailableChangeListener 743 * @tc.desc: SetBufferAvailableChangeListener Test 744 * @tc.type: FUNC 745 */ 746HWTEST_F(WindowSessionTest3, SetBufferAvailableChangeListener, Function | SmallTest | Level2) 747{ 748 ASSERT_NE(session_, nullptr); 749 session_->SetSessionState(SessionState::STATE_CONNECT); 750 session_->SetSessionStateChangeNotifyManagerListener(nullptr); 751 752 session_->bufferAvailable_ = true; 753 session_->SetBufferAvailableChangeListener(nullptr); 754 755 int resultValue = 0; 756 NotifyBufferAvailableChangeFunc func = [&resultValue](const bool isAvailable) { 757 resultValue = 1; 758 }; 759 session_->SetBufferAvailableChangeListener(func); 760 EXPECT_EQ(resultValue, 1); 761} 762 763/** 764 * @tc.name: SetLeashWindowSurfaceNodeChangedListener 765 * @tc.desc: SetLeashWindowSurfaceNodeChangedListener Test 766 * @tc.type: FUNC 767 */ 768HWTEST_F(WindowSessionTest3, SetLeashWindowSurfaceNodeChangedListener, Function | SmallTest | Level2) 769{ 770 ASSERT_NE(session_, nullptr); 771 int resultValue = 0; 772 NotifyLeashWindowSurfaceNodeChangedFunc func = [&resultValue]() { 773 resultValue = 1; 774 }; 775 session_->SetLeashWindowSurfaceNodeChangedListener(func); 776 session_->SetLeashWinSurfaceNode(nullptr); 777 EXPECT_EQ(resultValue, 1); 778 session_->SetLeashWindowSurfaceNodeChangedListener(nullptr); 779} 780 781/** 782 * @tc.name: NotifySessionFocusableChange 783 * @tc.desc: NotifySessionFocusableChange Test 784 * @tc.type: FUNC 785 */ 786HWTEST_F(WindowSessionTest3, NotifySessionFocusableChange, Function | SmallTest | Level2) 787{ 788 ASSERT_NE(session_, nullptr); 789 int resultValue = 0; 790 NotifySessionFocusableChangeFunc func = [&resultValue](const bool isFocusable) { 791 resultValue = 1; 792 }; 793 session_->SetSessionFocusableChangeListener(func); 794 session_->NotifySessionFocusableChange(true); 795 796 session_->sessionFocusableChangeFunc_ = nullptr; 797 session_->NotifySessionFocusableChange(true); 798 EXPECT_EQ(resultValue, 1); 799} 800 801/** 802 * @tc.name: GetStateFromManager 803 * @tc.desc: GetStateFromManager Test 804 * @tc.type: FUNC 805 */ 806HWTEST_F(WindowSessionTest3, GetStateFromManager, Function | SmallTest | Level2) 807{ 808 ManagerState key = ManagerState{0}; 809 GetStateFromManagerFunc func = [](const ManagerState key) { 810 return true; 811 }; 812 session_->getStateFromManagerFunc_ = func; 813 session_->GetStateFromManager(key); 814 815 session_->getStateFromManagerFunc_ = nullptr; 816 ASSERT_EQ(false, session_->GetStateFromManager(key)); 817 818 // 覆盖default分支 819 key = ManagerState{-1}; 820 ASSERT_EQ(false, session_->GetStateFromManager(key)); 821} 822 823/** 824 * @tc.name: NotifyUIRequestFocus 825 * @tc.desc: NotifyUIRequestFocus Test 826 * @tc.type: FUNC 827 */ 828HWTEST_F(WindowSessionTest3, NotifyUIRequestFocus, Function | SmallTest | Level2) 829{ 830 session_->requestFocusFunc_ = []() {}; 831 session_->NotifyUIRequestFocus(); 832 833 ASSERT_NE(session_, nullptr); 834} 835 836/** 837 * @tc.name: SetCompatibleModeInPc 838 * @tc.desc: SetCompatibleModeInPc Test 839 * @tc.type: FUNC 840 */ 841HWTEST_F(WindowSessionTest3, SetCompatibleModeInPc, Function | SmallTest | Level2) 842{ 843 session_->property_ = nullptr; 844 auto enable = true; 845 auto isSupportDragInPcCompatibleMode = true; 846 ASSERT_EQ(WSError::WS_ERROR_NULLPTR, session_->SetCompatibleModeInPc(enable, isSupportDragInPcCompatibleMode)); 847 848 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 849 ASSERT_EQ(WSError::WS_OK, session_->SetCompatibleModeInPc(enable, isSupportDragInPcCompatibleMode)); 850 851 enable = false; 852 ASSERT_EQ(WSError::WS_OK, session_->SetCompatibleModeInPc(enable, isSupportDragInPcCompatibleMode)); 853} 854 855/** 856 * @tc.name: CompatibleFullScreen Recover&Minimize&Close 857 * @tc.desc: CompatibleFullScreen Recover&Minimize&Close Test 858 * @tc.type: FUNC 859 */ 860HWTEST_F(WindowSessionTest3, CompatibleFullScreen, Function | SmallTest | Level2) 861{ 862 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 863 EXPECT_NE(nullptr, mockSessionStage); 864 session_->sessionStage_ = mockSessionStage; 865 866 session_->sessionInfo_.isSystem_ = false; 867 session_->state_ = SessionState::STATE_CONNECT; 868 session_->CompatibleFullScreenRecover(); 869 session_->CompatibleFullScreenMinimize(); 870 session_->CompatibleFullScreenClose(); 871 session_->state_ = SessionState::STATE_DISCONNECT; 872 873 session_->sessionInfo_.isSystem_ = true; 874 ASSERT_EQ(WSError::WS_ERROR_INVALID_SESSION, session_->CompatibleFullScreenRecover()); 875 ASSERT_EQ(WSError::WS_ERROR_INVALID_SESSION, session_->CompatibleFullScreenMinimize()); 876 ASSERT_EQ(WSError::WS_ERROR_INVALID_SESSION, session_->CompatibleFullScreenClose()); 877} 878 879/** 880 * @tc.name: NotifySessionTouchableChange 881 * @tc.desc: NotifySessionTouchableChange Test 882 * @tc.type: FUNC 883 */ 884HWTEST_F(WindowSessionTest3, NotifySessionTouchableChange, Function | SmallTest | Level2) 885{ 886 ASSERT_NE(session_, nullptr); 887 int resultValue = 0; 888 NotifySessionTouchableChangeFunc func = [&resultValue](const bool touchable) { 889 resultValue = 1; 890 }; 891 session_->SetSessionTouchableChangeListener(func); 892 session_->NotifySessionTouchableChange(true); 893 EXPECT_EQ(resultValue, 1); 894} 895 896/** 897 * @tc.name: NotifyClick 898 * @tc.desc: NotifyClick Test 899 * @tc.type: FUNC 900 */ 901HWTEST_F(WindowSessionTest3, NotifyClick, Function | SmallTest | Level2) 902{ 903 ASSERT_NE(session_, nullptr); 904 int resultValue = 0; 905 bool hasRequestFocus = true; 906 NotifyClickFunc func = [&resultValue, &hasRequestFocus](bool requestFocus) { 907 resultValue = 1; 908 hasRequestFocus = requestFocus; 909 }; 910 session_->SetClickListener(func); 911 session_->NotifyClick(false); 912 EXPECT_EQ(resultValue, 1); 913 EXPECT_EQ(hasRequestFocus, false); 914} 915 916/** 917 * @tc.name: NotifyRequestFocusStatusNotifyManager 918 * @tc.desc: NotifyRequestFocusStatusNotifyManager Test 919 * @tc.type: FUNC 920 */ 921HWTEST_F(WindowSessionTest3, NotifyRequestFocusStatusNotifyManager, Function | SmallTest | Level2) 922{ 923 ASSERT_NE(session_, nullptr); 924 int resultValue = 0; 925 NotifyRequestFocusStatusNotifyManagerFunc func = [&resultValue](int32_t persistentId, 926 const bool isFocused, const bool byForeground, FocusChangeReason reason) { 927 resultValue = 1; 928 }; 929 session_->SetRequestFocusStatusNotifyManagerListener(func); 930 FocusChangeReason reason = FocusChangeReason::SCB_SESSION_REQUEST; 931 session_->NotifyRequestFocusStatusNotifyManager(true, false, reason); 932 EXPECT_EQ(resultValue, 1); 933} 934 935/** 936 * @tc.name: PresentFoucusIfNeed 937 * @tc.desc: PresentFoucusIfNeed Test 938 * @tc.type: FUNC 939 */ 940HWTEST_F(WindowSessionTest3, PresentFoucusIfNeed, Function | SmallTest | Level2) 941{ 942 ASSERT_NE(session_, nullptr); 943 int32_t pointerAction = MMI::PointerEvent::POINTER_ACTION_DOWN; 944 session_->PresentFoucusIfNeed(pointerAction); 945 pointerAction = MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN; 946 session_->PresentFoucusIfNeed(pointerAction); 947 session_->property_->focusable_ = false; 948 session_->PresentFoucusIfNeed(pointerAction); 949 session_->isFocused_ = true; 950 session_->PresentFoucusIfNeed(pointerAction); 951 EXPECT_EQ(true, session_->CheckPointerEventDispatch(nullptr)); 952} 953 954/** 955 * @tc.name: UpdateFocus03 956 * @tc.desc: UpdateFocus Test 957 * @tc.type: FUNC 958 */ 959HWTEST_F(WindowSessionTest3, UpdateFocus03, Function | SmallTest | Level2) 960{ 961 ASSERT_NE(session_, nullptr); 962 session_->isFocused_ = true; 963 EXPECT_EQ(WSError::WS_OK, session_->UpdateFocus(false)); 964} 965 966/** 967 * @tc.name: NotifyFocusStatus 968 * @tc.desc: NotifyFocusStatus Test 969 * @tc.type: FUNC 970 */ 971HWTEST_F(WindowSessionTest3, NotifyFocusStatus, Function | SmallTest | Level2) 972{ 973 ASSERT_NE(session_, nullptr); 974 session_->state_ = SessionState::STATE_CONNECT; 975 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 976 EXPECT_NE(nullptr, mockSessionStage); 977 session_->sessionStage_ = mockSessionStage; 978 EXPECT_EQ(WSError::WS_OK, session_->NotifyFocusStatus(true)); 979 session_->sessionStage_ = nullptr; 980 EXPECT_EQ(WSError::WS_ERROR_NULLPTR, session_->NotifyFocusStatus(true)); 981} 982 983/** 984 * @tc.name: RequestFocus 985 * @tc.desc: RequestFocus Test 986 * @tc.type: FUNC 987 */ 988HWTEST_F(WindowSessionTest3, RequestFocus, Function | SmallTest | Level2) 989{ 990 ASSERT_NE(session_, nullptr); 991 session_->state_ = SessionState::STATE_FOREGROUND; 992 session_->sessionInfo_.isSystem_ = false; 993 EXPECT_EQ(WSError::WS_OK, session_->RequestFocus(true)); 994 EXPECT_EQ(WSError::WS_OK, session_->RequestFocus(false)); 995} 996 997/** 998 * @tc.name: UpdateWindowMode 999 * @tc.desc: UpdateWindowMode Test 1000 * @tc.type: FUNC 1001 */ 1002HWTEST_F(WindowSessionTest3, UpdateWindowMode, Function | SmallTest | Level2) 1003{ 1004 ASSERT_NE(session_, nullptr); 1005 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 1006 EXPECT_NE(nullptr, mockSessionStage); 1007 session_->sessionStage_ = mockSessionStage; 1008 1009 session_->state_ = SessionState::STATE_END; 1010 auto result = session_->UpdateWindowMode(WindowMode::WINDOW_MODE_UNDEFINED); 1011 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_SESSION); 1012 1013 session_->state_ = SessionState::STATE_DISCONNECT; 1014 result = session_->UpdateWindowMode(WindowMode::WINDOW_MODE_UNDEFINED); 1015 EXPECT_EQ(session_->property_->windowMode_, WindowMode::WINDOW_MODE_UNDEFINED); 1016 EXPECT_EQ(session_->property_->isNeedUpdateWindowMode_, true); 1017 EXPECT_EQ(result, WSError::WS_OK); 1018 1019 session_->state_ = SessionState::STATE_CONNECT; 1020 result = session_->UpdateWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY); 1021 EXPECT_EQ(session_->property_->windowMode_, WindowMode::WINDOW_MODE_SPLIT_SECONDARY); 1022 EXPECT_EQ(session_->property_->maximizeMode_, MaximizeMode::MODE_RECOVER); 1023 EXPECT_EQ(result, WSError::WS_OK); 1024 1025 session_->state_ = SessionState::STATE_CONNECT; 1026 result = session_->UpdateWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY); 1027 EXPECT_EQ(result, WSError::WS_OK); 1028 1029 session_->state_ = SessionState::STATE_CONNECT; 1030 result = session_->UpdateWindowMode(WindowMode::WINDOW_MODE_UNDEFINED); 1031 EXPECT_EQ(result, WSError::WS_OK); 1032 1033 session_->sessionStage_ = nullptr; 1034 result = session_->UpdateWindowMode(WindowMode::WINDOW_MODE_UNDEFINED); 1035 EXPECT_EQ(result, WSError::WS_ERROR_NULLPTR); 1036} 1037 1038/** 1039 * @tc.name: RectSizeCheckProcess 1040 * @tc.desc: RectSizeCheckProcess Test 1041 * @tc.type: FUNC 1042 */ 1043HWTEST_F(WindowSessionTest3, RectSizeCheckProcess, Function | SmallTest | Level2) 1044{ 1045 ASSERT_NE(session_, nullptr); 1046 session_->RectSizeCheckProcess(1, 0, 2, 0, 0); 1047 session_->RectSizeCheckProcess(1, 0, 1, 0, 0); 1048 session_->RectSizeCheckProcess(0, 1, 0, 2, 0); 1049 session_->RectSizeCheckProcess(0, 1, 0, 0, 0); 1050 EXPECT_EQ(true, session_->CheckPointerEventDispatch(nullptr)); 1051} 1052 1053/** 1054 * @tc.name: RectCheckProcess 1055 * @tc.desc: RectCheckProcess Test 1056 * @tc.type: FUNC 1057 */ 1058HWTEST_F(WindowSessionTest3, RectCheckProcess, Function | SmallTest | Level2) 1059{ 1060 ASSERT_NE(session_, nullptr); 1061 session_->isVisible_ = true; 1062 session_->property_ = nullptr; 1063 session_->RectCheckProcess(); 1064 1065 session_->state_ = SessionState::STATE_FOREGROUND; 1066 session_->property_ = nullptr; 1067 session_->RectCheckProcess(); 1068 EXPECT_EQ(true, session_->CheckPointerEventDispatch(nullptr)); 1069} 1070 1071/** 1072 * @tc.name: RectCheckProcess01 1073 * @tc.desc: RectCheckProcess01 Test 1074 * @tc.type: FUNC 1075 */ 1076HWTEST_F(WindowSessionTest3, RectCheckProcess01, Function | SmallTest | Level2) 1077{ 1078 ASSERT_NE(session_, nullptr); 1079 session_->state_ = SessionState::STATE_INACTIVE; 1080 session_->isVisible_ = false; 1081 session_->property_ = nullptr; 1082 session_->RectCheckProcess(); 1083 1084 session_->state_ = SessionState::STATE_ACTIVE; 1085 session_->isVisible_ = true; 1086 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 1087 session_->RectCheckProcess(); 1088 1089 session_->property_->displayId_ = 0; 1090 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0); 1091 ASSERT_NE(screenSession, nullptr); 1092 ScreenProperty screenProperty = screenSession->GetScreenProperty(); 1093 ASSERT_NE(&screenProperty, nullptr); 1094 screenSession->screenId_ = 0; 1095 screenSession->SetVirtualPixelRatio(0.0f); 1096 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(0, screenSession)); 1097 session_->RectCheckProcess(); 1098 1099 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear(); 1100 screenSession->SetVirtualPixelRatio(1.0f); 1101 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(0, screenSession)); 1102 session_->RectCheckProcess(); 1103 1104 WSRect rect = {0, 0, 0, 0}; 1105 session_->winRect_ = rect; 1106 session_->RectCheckProcess(); 1107 1108 session_->winRect_.height_ = 200; 1109 session_->RectCheckProcess(); 1110 1111 session_->aspectRatio_ = 0.0f; 1112 session_->RectCheckProcess(); 1113 1114 session_->aspectRatio_ = 0.5f; 1115 session_->RectCheckProcess(); 1116 1117 session_->winRect_.width_ = 200; 1118 session_->RectCheckProcess(); 1119 1120 session_->aspectRatio_ = 1.0f; 1121 session_->RectCheckProcess(); 1122 1123 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear(); 1124} 1125 1126/** 1127 * @tc.name: SetAcquireRotateAnimationConfigFunc 1128 * @tc.desc: SetAcquireRotateAnimationConfigFunc Test 1129 * @tc.type: FUNC 1130 */ 1131HWTEST_F(WindowSessionTest3, SetAcquireRotateAnimationConfigFunc, Function | SmallTest | Level2) 1132{ 1133 ASSERT_NE(session_, nullptr); 1134 session_->SetAcquireRotateAnimationConfigFunc(nullptr); 1135 ASSERT_EQ(session_->acquireRotateAnimationConfigFunc_, nullptr); 1136 int32_t duration = session_->GetRotateAnimationDuration(); 1137 ASSERT_EQ(duration, ROTATE_ANIMATION_DURATION); 1138 1139 AcquireRotateAnimationConfigFunc func = [](RotateAnimationConfig& config) { 1140 config.duration_ = 800; 1141 }; 1142 session_->SetAcquireRotateAnimationConfigFunc(func); 1143 ASSERT_NE(session_->acquireRotateAnimationConfigFunc_, nullptr); 1144 duration = session_->GetRotateAnimationDuration(); 1145 ASSERT_EQ(duration, 800); 1146} 1147 1148/** 1149 * @tc.name: SetIsPcAppInPad 1150 * @tc.desc: SetIsPcAppInPad Test 1151 * @tc.type: FUNC 1152 */ 1153HWTEST_F(WindowSessionTest3, SetIsPcAppInPad, Function | SmallTest | Level2) 1154{ 1155 ASSERT_NE(session_, nullptr); 1156 bool isPcAppInPad = false; 1157 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 1158 auto result = session_->SetIsPcAppInPad(isPcAppInPad); 1159 EXPECT_EQ(result, WSError::WS_OK); 1160 1161 session_->property_ = nullptr; 1162 EXPECT_EQ(WSError::WS_ERROR_NULLPTR, session_->SetIsPcAppInPad(isPcAppInPad)); 1163} 1164 1165/** 1166 * @tc.name: SetBufferAvailable 1167 * @tc.desc: SetBufferAvailable Test 1168 * @tc.type: FUNC 1169 */ 1170HWTEST_F(WindowSessionTest3, SetBufferAvailable, Function | SmallTest | Level2) 1171{ 1172 int resultValue = 0; 1173 NotifyBufferAvailableChangeFunc func = [&resultValue](const bool isAvailable) { 1174 resultValue = 1; 1175 }; 1176 session_->SetBufferAvailableChangeListener(func); 1177 session_->SetBufferAvailable(true); 1178 ASSERT_EQ(session_->bufferAvailable_, true); 1179} 1180 1181/** 1182 * @tc.name: NotifySessionInfoChange 1183 * @tc.desc: NotifySessionInfoChange Test 1184 * @tc.type: FUNC 1185 */ 1186HWTEST_F(WindowSessionTest3, NotifySessionInfoChange, Function | SmallTest | Level2) 1187{ 1188 int resultValue = 0; 1189 NotifyBufferAvailableChangeFunc func = [&resultValue](const bool isAvailable) { 1190 resultValue = 1; 1191 }; 1192 session_->SetSessionInfoChangeNotifyManagerListener(func); 1193 session_->NotifySessionInfoChange(); 1194 ASSERT_EQ(resultValue, 1); 1195} 1196 1197/** 1198 * @tc.name: SetCompatibleModeEnableInPad 1199 * @tc.desc: SetCompatibleModeEnableInPad Test 1200 * @tc.type: FUNC 1201 */ 1202HWTEST_F(WindowSessionTest3, SetCompatibleModeEnableInPad, Function | SmallTest | Level2) 1203{ 1204 ASSERT_NE(session_, nullptr); 1205 session_->state_ = SessionState::STATE_FOREGROUND; 1206 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 1207 EXPECT_NE(nullptr, mockSessionStage); 1208 session_->sessionStage_ = mockSessionStage; 1209 session_->property_ = nullptr; 1210 bool enable = true; 1211 ASSERT_EQ(WSError::WS_ERROR_NULLPTR, session_->SetCompatibleModeEnableInPad(enable)); 1212 1213 session_->property_ = sptr<WindowSessionProperty>::MakeSptr(); 1214 ASSERT_EQ(WSError::WS_OK, session_->SetCompatibleModeEnableInPad(enable)); 1215 1216 enable = false; 1217 ASSERT_EQ(WSError::WS_OK, session_->SetCompatibleModeEnableInPad(enable)); 1218} 1219 1220/** 1221 * @tc.name: RectSizeCheckProcess01 1222 * @tc.desc: RectSizeCheckProcess Test 1223 * @tc.type: FUNC 1224 */ 1225HWTEST_F(WindowSessionTest3, RectSizeCheckProcess01, Function | SmallTest | Level2) 1226{ 1227 session_->SetSessionProperty(nullptr); 1228 session_->RectSizeCheckProcess(1, 1, 2, 2, 0); 1229 ASSERT_EQ(session_->property_, nullptr); 1230} 1231 1232/** 1233 * @tc.name: GetSurfaceNodeForMoveDrag 1234 * @tc.desc: GetSurfaceNodeForMoveDrag Test 1235 * @tc.type: FUNC 1236 */ 1237HWTEST_F(WindowSessionTest3, GetSurfaceNodeForMoveDrag, Function | SmallTest | Level2) 1238{ 1239 ASSERT_NE(session_, nullptr); 1240 session_->leashWinSurfaceNode_ = nullptr; 1241 session_->surfaceNode_ = nullptr; 1242 std::shared_ptr<RSSurfaceNode> res = session_->GetSurfaceNodeForMoveDrag(); 1243 ASSERT_EQ(res, nullptr); 1244} 1245 1246/** 1247 * @tc.name: GetSnapshotPixelMap 1248 * @tc.desc: GetSnapshotPixelMap Test 1249 * @tc.type: FUNC 1250 */ 1251HWTEST_F(WindowSessionTest3, GetSnapshotPixelMap, Function | SmallTest | Level2) 1252{ 1253 session_->scenePersistence_ = nullptr; 1254 EXPECT_EQ(nullptr, session_->GetSnapshotPixelMap(6.6f, 8.8f)); 1255 session_->scenePersistence_ = sptr<ScenePersistence>::MakeSptr("GetSnapshotPixelMap", 2024); 1256 EXPECT_NE(nullptr, session_->scenePersistence_); 1257 session_->scenePersistence_->isSavingSnapshot_.store(true); 1258 session_->snapshot_ = nullptr; 1259 EXPECT_EQ(nullptr, session_->GetSnapshotPixelMap(6.6f, 8.8f)); 1260} 1261 1262/** 1263 * @tc.name: ResetDirtyFlags 1264 * @tc.desc: ResetDirtyFlags Test 1265 * @tc.type: FUNC 1266 */ 1267HWTEST_F(WindowSessionTest3, ResetDirtyFlags, Function | SmallTest | Level2) 1268{ 1269 session_->isVisible_ = false; 1270 session_->dirtyFlags_ = 64; 1271 session_->ResetDirtyFlags(); 1272 EXPECT_EQ(64, session_->dirtyFlags_); 1273 1274 session_->isVisible_ = true; 1275 session_->dirtyFlags_ = 16; 1276 session_->ResetDirtyFlags(); 1277 EXPECT_EQ(0, session_->dirtyFlags_); 1278} 1279 1280/** 1281 * @tc.name: SetMainSessionUIStateDirty 1282 * @tc.desc: SetMainSessionUIStateDirty Test 1283 * @tc.type: FUNC 1284 */ 1285HWTEST_F(WindowSessionTest3, SetMainSessionUIStateDirty, Function | SmallTest | Level2) 1286{ 1287 SessionInfo infoDirty; 1288 infoDirty.abilityName_ = "SetMainSessionUIStateDirty"; 1289 infoDirty.moduleName_ = "SetMainSessionUIStateDirty"; 1290 infoDirty.bundleName_ = "SetMainSessionUIStateDirty"; 1291 infoDirty.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_END); 1292 sptr<Session> sessionDirty = sptr<Session>::MakeSptr(infoDirty); 1293 EXPECT_NE(nullptr, sessionDirty); 1294 1295 session_->parentSession_ = nullptr; 1296 EXPECT_EQ(nullptr, session_->GetParentSession()); 1297 sessionDirty->SetUIStateDirty(false); 1298 session_->SetMainSessionUIStateDirty(false); 1299 EXPECT_EQ(false, sessionDirty->GetUIStateDirty()); 1300 1301 session_->SetParentSession(sessionDirty); 1302 EXPECT_EQ(sessionDirty, session_->GetParentSession()); 1303 session_->SetMainSessionUIStateDirty(false); 1304 EXPECT_EQ(false, sessionDirty->GetUIStateDirty()); 1305 1306 infoDirty.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE); 1307 sptr<Session> sessionUIState = sptr<Session>::MakeSptr(infoDirty); 1308 EXPECT_NE(nullptr, sessionUIState); 1309 session_->SetParentSession(sessionUIState); 1310 session_->SetMainSessionUIStateDirty(true); 1311 EXPECT_EQ(true, sessionUIState->GetUIStateDirty()); 1312} 1313 1314/** 1315 * @tc.name: CompatibleFullScreenRecover 1316 * @tc.desc: CompatibleFullScreenRecover Test 1317 * @tc.type: FUNC 1318 */ 1319HWTEST_F(WindowSessionTest3, CompatibleFullScreenRecover, Function | SmallTest | Level2) 1320{ 1321 ASSERT_NE(session_, nullptr); 1322 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 1323 ASSERT_NE(nullptr, mockSessionStage); 1324 session_->sessionStage_ = mockSessionStage; 1325 session_->sessionInfo_.isSystem_ = true; 1326 auto result = session_->CompatibleFullScreenRecover(); 1327 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_SESSION); 1328 1329 session_->sessionInfo_.isSystem_ = false; 1330 session_->SetSessionState(SessionState::STATE_FOREGROUND); 1331 result = session_->CompatibleFullScreenRecover(); 1332 ASSERT_EQ(result, WSError::WS_OK); 1333} 1334 1335/** 1336 * @tc.name: CompatibleFullScreenMinimize 1337 * @tc.desc: CompatibleFullScreenMinimize Test 1338 * @tc.type: FUNC 1339 */ 1340HWTEST_F(WindowSessionTest3, CompatibleFullScreenMinimize, Function | SmallTest | Level2) 1341{ 1342 ASSERT_NE(session_, nullptr); 1343 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 1344 ASSERT_NE(nullptr, mockSessionStage); 1345 session_->sessionStage_ = mockSessionStage; 1346 session_->sessionInfo_.isSystem_ = true; 1347 auto result = session_->CompatibleFullScreenMinimize(); 1348 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_SESSION); 1349 1350 session_->sessionInfo_.isSystem_ = false; 1351 session_->SetSessionState(SessionState::STATE_FOREGROUND); 1352 result = session_->CompatibleFullScreenMinimize(); 1353 ASSERT_EQ(result, WSError::WS_OK); 1354} 1355 1356/** 1357 * @tc.name: CompatibleFullScreenClose 1358 * @tc.desc: CompatibleFullScreenClose Test 1359 * @tc.type: FUNC 1360 */ 1361HWTEST_F(WindowSessionTest3, CompatibleFullScreenClose, Function | SmallTest | Level2) 1362{ 1363 ASSERT_NE(session_, nullptr); 1364 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr(); 1365 ASSERT_NE(nullptr, mockSessionStage); 1366 session_->sessionStage_ = mockSessionStage; 1367 session_->sessionInfo_.isSystem_ = true; 1368 auto result = session_->CompatibleFullScreenClose(); 1369 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_SESSION); 1370 1371 session_->sessionInfo_.isSystem_ = false; 1372 session_->SetSessionState(SessionState::STATE_FOREGROUND); 1373 result = session_->CompatibleFullScreenClose(); 1374 ASSERT_EQ(result, WSError::WS_OK); 1375} 1376} 1377} // namespace Rosen 1378} // namespace OHOS 1379