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 <pointer_event.h>
18 
19 #include "common/include/session_permission.h"
20 #include "display_manager.h"
21 #include "input_event.h"
22 #include "key_event.h"
23 
24 #include "mock/mock_session_stage.h"
25 #include "pointer_event.h"
26 
27 #include "screen_manager.h"
28 #include "session/host/include/sub_session.h"
29 #include "session/host/include/main_session.h"
30 #include "session/host/include/scene_session.h"
31 #include "session/host/include/system_session.h"
32 #include "session/screen/include/screen_session.h"
33 #include "screen_session_manager_client/include/screen_session_manager_client.h"
34 #include "wm_common.h"
35 #include "window_helper.h"
36 #include "ui/rs_surface_node.h"
37 
38 using namespace testing;
39 using namespace testing::ext;
40 namespace OHOS {
41 namespace Rosen {
42 
43 class GetKeyboardGravitySceneSession : public SceneSession {
44 public:
GetKeyboardGravitySceneSession(const SessionInfo& info, const sptr<SpecificSessionCallback>& specificCallback)45     GetKeyboardGravitySceneSession(const SessionInfo& info, const sptr<SpecificSessionCallback>& specificCallback)
46         : SceneSession(info, specificCallback)
47     {
48     }
49 
50     SessionGravity GetKeyboardGravity() const override
51     {
52         return SessionGravity::SESSION_GRAVITY_FLOAT;
53     }
54 };
55 
56 class SceneSessionTest5 : public testing::Test {
57 public:
58     static void SetUpTestCase();
59     static void TearDownTestCase();
60     void SetUp() override;
61     void TearDown() override;
62 };
63 
SetUpTestCase()64 void SceneSessionTest5::SetUpTestCase()
65 {
66 }
67 
TearDownTestCase()68 void SceneSessionTest5::TearDownTestCase()
69 {
70 }
71 
SetUp()72 void SceneSessionTest5::SetUp()
73 {
74 }
75 
TearDown()76 void SceneSessionTest5::TearDown()
77 {
78 }
79 
80 namespace {
81 
82 /**
83  * @tc.name: NotifyClientToUpdateRectTask
84  * @tc.desc: NotifyClientToUpdateRectTask function
85  * @tc.type: FUNC
86  */
HWTEST_F(SceneSessionTest5, NotifyClientToUpdateRectTask, Function | SmallTest | Level2)87 HWTEST_F(SceneSessionTest5, NotifyClientToUpdateRectTask, Function | SmallTest | Level2)
88 {
89     SessionInfo info;
90     info.abilityName_ = "NotifyClientToUpdateRectTask";
91     info.bundleName_ = "NotifyClientToUpdateRectTask";
92     info.isSystem_ = true;
93 
94     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
95     EXPECT_NE(session, nullptr);
96 
97     session->moveDragController_ = nullptr;
98     session->isKeyboardPanelEnabled_ = false;
99 
100     session->Session::UpdateSizeChangeReason(SizeChangeReason::UNDEFINED);
101     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->NotifyClientToUpdateRectTask("SceneSessionTest5", nullptr));
102     session->Session::UpdateSizeChangeReason(SizeChangeReason::MOVE);
103     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->NotifyClientToUpdateRectTask("SceneSessionTest5", nullptr));
104     session->Session::UpdateSizeChangeReason(SizeChangeReason::RESIZE);
105     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->NotifyClientToUpdateRectTask("SceneSessionTest5", nullptr));
106     session->Session::UpdateSizeChangeReason(SizeChangeReason::RECOVER);
107     EXPECT_EQ(session->reason_, SizeChangeReason::RECOVER);
108     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->NotifyClientToUpdateRectTask("SceneSessionTest5", nullptr));
109 
110     session->moveDragController_ = sptr<MoveDragController>::MakeSptr(2024);
111     session->moveDragController_->isStartDrag_ = true;
112     session->moveDragController_->isStartMove_ = true;
113     session->Session::UpdateSizeChangeReason(SizeChangeReason::MOVE);
114     session->isKeyboardPanelEnabled_ = true;
115     info.windowType_ = static_cast<uint32_t>(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
116     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->NotifyClientToUpdateRectTask("SceneSessionTest5", nullptr));
117     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
118     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->NotifyClientToUpdateRectTask("SceneSessionTest5", nullptr));
119 
120     session->Session::UpdateSizeChangeReason(SizeChangeReason::UNDEFINED);
121     EXPECT_EQ(WSError::WS_ERROR_REPEAT_OPERATION, session->NotifyClientToUpdateRectTask("SceneSessionTest5", nullptr));
122 
123     session->Session::UpdateSizeChangeReason(SizeChangeReason::MOVE);
124     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_KEYBOARD_PANEL);
125     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->NotifyClientToUpdateRectTask("SceneSessionTest5", nullptr));
126 }
127 
128 /**
129  * @tc.name: GetSystemAvoidArea
130  * @tc.desc: GetSystemAvoidArea function
131  * @tc.type: FUNC
132  */
HWTEST_F(SceneSessionTest5, GetSystemAvoidArea, Function | SmallTest | Level2)133 HWTEST_F(SceneSessionTest5, GetSystemAvoidArea, Function | SmallTest | Level2)
134 {
135     SessionInfo info;
136     info.abilityName_ = "GetSystemAvoidArea";
137     info.bundleName_ = "GetSystemAvoidArea";
138 
139     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
140     EXPECT_NE(session, nullptr);
141     WSRect rect;
142     AvoidArea avoidArea;
143     session->property_->SetWindowFlags(0);
144     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
145     session->isDisplayStatusBarTemporarily_.store(true);
146     session->GetSystemAvoidArea(rect, avoidArea);
147     ASSERT_NE(session->GetSessionProperty(), nullptr);
148     EXPECT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, session->GetSessionProperty()->GetWindowMode());
149 
150     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
151     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_END);
152     session->isDisplayStatusBarTemporarily_.store(false);
153     session->GetSystemAvoidArea(rect, avoidArea);
154 
155     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
156     SystemSessionConfig systemConfig;
157     systemConfig.windowUIType_ = WindowUIType::PC_WINDOW;
158     session->SetSystemConfig(systemConfig);
159     sptr<SceneSession::SpecificSessionCallback> specificCallback =
160         sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
161     session->specificCallback_ = specificCallback;
162     session->specificCallback_->onGetSceneSessionVectorByType_ = nullptr;
163     session->GetSystemAvoidArea(rect, avoidArea);
164 
165     systemConfig.windowUIType_ = WindowUIType::PHONE_WINDOW;
166     GetSceneSessionVectorByTypeCallback func = [&session](WindowType type, uint64_t displayId) {
167         std::vector<sptr<SceneSession>> vSession;
168         vSession.push_back(session);
169         return vSession;
170     };
171     session->property_->SetDisplayId(2024);
172     sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr();
173     ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
174     ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(2024, screenSession));
175     session->specificCallback_->onGetSceneSessionVectorByType_ = func;
176     session->GetSystemAvoidArea(rect, avoidArea);
177     ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
178 }
179 
180 /**
181  * @tc.name: GetSystemAvoidArea01
182  * @tc.desc: GetSystemAvoidArea01 function
183  * @tc.type: FUNC
184  */
HWTEST_F(SceneSessionTest5, GetSystemAvoidArea01, Function | SmallTest | Level2)185 HWTEST_F(SceneSessionTest5, GetSystemAvoidArea01, Function | SmallTest | Level2)
186 {
187     SessionInfo info;
188     info.abilityName_ = "GetSystemAvoidArea01";
189     info.bundleName_ = "GetSystemAvoidArea01";
190 
191     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
192     EXPECT_NE(session, nullptr);
193     WSRect rect;
194     AvoidArea avoidArea;
195     session->property_->SetWindowFlags(0);
196 
197     session->isDisplayStatusBarTemporarily_.store(false);
198 
199     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
200     SystemSessionConfig systemConfig;
201 
202     session->SetSystemConfig(systemConfig);
203     sptr<SceneSession::SpecificSessionCallback> specificCallback =
204         sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
205     session->specificCallback_ = specificCallback;
206 
207     systemConfig.windowUIType_ = WindowUIType::PHONE_WINDOW;
208     GetSceneSessionVectorByTypeCallback func = [&session](WindowType type, uint64_t displayId) {
209         std::vector<sptr<SceneSession>> vSession;
210         vSession.push_back(session);
211         return vSession;
212     };
213     session->property_->SetDisplayId(2024);
214     sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr();
215     ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
216     ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(2024, screenSession));
217     session->specificCallback_->onGetSceneSessionVectorByType_ = func;
218     ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
219 
220     session->property_->SetDisplayId(1024);
221     session->Session::SetFloatingScale(0.0f);
222 
223     session->Session::SetFloatingScale(0.5f);
224     EXPECT_EQ(0.5f, session->Session::GetFloatingScale());
225     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
226     session->GetSystemAvoidArea(rect, avoidArea);
227     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
228     session->GetSystemAvoidArea(rect, avoidArea);
229     rect.height_ = 3;
230     rect.width_ =4;
231     session->GetSystemAvoidArea(rect, avoidArea);
232 
233     session->isVisible_ = true;
234     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
235     session->GetSystemAvoidArea(rect, avoidArea);
236 }
237 
238 /**
239  * @tc.name: NotifyOutsideDownEvent
240  * @tc.desc: NotifyOutsideDownEvent function
241  * @tc.type: FUNC
242  */
HWTEST_F(SceneSessionTest5, NotifyOutsideDownEvent, Function | SmallTest | Level2)243 HWTEST_F(SceneSessionTest5, NotifyOutsideDownEvent, Function | SmallTest | Level2)
244 {
245     SessionInfo info;
246     info.abilityName_ = "NotifyOutsideDownEvent";
247     info.bundleName_ = "NotifyOutsideDownEvent";
248 
249     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
250     EXPECT_NE(session, nullptr);
251     std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
252     pointerEvent->SetPointerAction(2);
253     pointerEvent->RemoveAllPointerItems();
254     session->NotifyOutsideDownEvent(pointerEvent);
255     pointerEvent->SetPointerAction(8);
256     MMI::PointerEvent::PointerItem pointerItem;
257     pointerItem.SetPointerId(2024);
258     pointerEvent->AddPointerItem(pointerItem);
259     pointerEvent->SetPointerId(2024);
260     session->NotifyOutsideDownEvent(pointerEvent);
261     sptr<SceneSession::SpecificSessionCallback> specificCallback =
262         sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
263     session->specificCallback_ = specificCallback;
264     session->specificCallback_->onOutsideDownEvent_ = nullptr;
265     session->NotifyOutsideDownEvent(pointerEvent);
266     OnOutsideDownEvent func = [](int32_t x, int32_t y) {
267         return;
268     };
269     session->specificCallback_->onOutsideDownEvent_ = func;
270     session->NotifyOutsideDownEvent(pointerEvent);
271     auto res = pointerEvent->GetPointerItem(2024, pointerItem);
272     EXPECT_EQ(true, res);
273 
274     pointerEvent->SetPointerAction(5);
275     session->NotifyOutsideDownEvent(pointerEvent);
276     pointerEvent->RemoveAllPointerItems();
277 }
278 
279 /**
280  * @tc.name: TransferPointerEvent
281  * @tc.desc: TransferPointerEvent function
282  * @tc.type: FUNC
283  */
HWTEST_F(SceneSessionTest5, TransferPointerEvent, Function | SmallTest | Level2)284 HWTEST_F(SceneSessionTest5, TransferPointerEvent, Function | SmallTest | Level2)
285 {
286     SessionInfo info;
287     info.abilityName_ = "TransferPointerEvent";
288     info.bundleName_ = "TransferPointerEvent";
289 
290     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
291     EXPECT_NE(session, nullptr);
292     std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();;
293 
294     SceneSession::enterSession_ = wptr<SceneSession>(session);
295     info.isSystem_ = false;
296     session->property_ = nullptr;
297     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->TransferPointerEvent(pointerEvent, false));
298 
299     info.isSystem_ = false;
300     pointerEvent->SetPointerAction(9);
301 
302     sptr<SceneSession::SpecificSessionCallback> specificCallback =
303         sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
304     session->specificCallback_ = specificCallback;
305     session->specificCallback_->onSessionTouchOutside_ = nullptr;
306     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->TransferPointerEvent(pointerEvent, false));
307 
308     NotifySessionTouchOutsideCallback func = [](int32_t persistentId) {
309         return;
310     };
311     session->specificCallback_->onSessionTouchOutside_ = func;
312     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->TransferPointerEvent(pointerEvent, false));
313     pointerEvent->SetPointerAction(2);
314     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->TransferPointerEvent(pointerEvent, false));
315 }
316 
317 /**
318  * @tc.name: TransferPointerEvent01
319  * @tc.desc: TransferPointerEvent01 function
320  * @tc.type: FUNC
321  */
HWTEST_F(SceneSessionTest5, TransferPointerEvent01, Function | SmallTest | Level2)322 HWTEST_F(SceneSessionTest5, TransferPointerEvent01, Function | SmallTest | Level2)
323 {
324     SessionInfo info;
325     info.abilityName_ = "TransferPointerEvent01";
326     info.bundleName_ = "TransferPointerEvent01";
327     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
328     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
329     EXPECT_NE(session, nullptr);
330     std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();;
331     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
332     session->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
333     session->ClearDialogVector();
334     session->moveDragController_ = sptr<MoveDragController>::MakeSptr(2024);
335     SystemSessionConfig systemConfig;
336     systemConfig.isSystemDecorEnable_ = false;
337     systemConfig.decorModeSupportInfo_ = 2;
338     session->SetSystemConfig(systemConfig);
339     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, session->TransferPointerEvent(pointerEvent, false));
340 
341     session->BindDialogToParentSession(session);
342     session->SetSessionState(SessionState::STATE_ACTIVE);
343     pointerEvent->SetPointerAction(5);
344     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
345     session->property_->SetDragEnabled(false);
346     systemConfig.isSystemDecorEnable_ = true;
347 
348     session->moveDragController_->isStartDrag_ = false;
349     EXPECT_EQ(WSError::WS_ERROR_NULLPTR, session->TransferPointerEvent(pointerEvent, false));
350 
351     pointerEvent->SetPointerAction(2);
352     EXPECT_EQ(WSError::WS_OK, session->TransferPointerEvent(pointerEvent, false));
353 
354     pointerEvent->SetPointerAction(5);
355     session->property_->SetDragEnabled(true);
356     systemConfig.windowUIType_ = WindowUIType::PHONE_WINDOW;
357     systemConfig.freeMultiWindowSupport_ = false;
358     session->moveDragController_->isStartDrag_ = true;
359     EXPECT_EQ(WSError::WS_ERROR_NULLPTR, session->TransferPointerEvent(pointerEvent, false));
360 
361     systemConfig.windowUIType_ = WindowUIType::PC_WINDOW;
362     EXPECT_EQ(WSError::WS_ERROR_NULLPTR, session->TransferPointerEvent(pointerEvent, false));
363     session->ClearDialogVector();
364 }
365 
366 
367 /**
368  * @tc.name: SetSurfaceBounds01
369  * @tc.desc: SetSurfaceBounds function
370  * @tc.type: FUNC
371  */
HWTEST_F(SceneSessionTest5, SetSurfaceBounds01, Function | SmallTest | Level2)372 HWTEST_F(SceneSessionTest5, SetSurfaceBounds01, Function | SmallTest | Level2)
373 {
374     SessionInfo info;
375     info.abilityName_ = "SetSurfaceBounds01";
376     info.bundleName_ = "SetSurfaceBounds01";
377     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_FLOAT);
378     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
379     struct RSSurfaceNodeConfig config;
380     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
381     session->surfaceNode_ = surfaceNode;
382     WSRect preRect = { 20, 20, 800, 800 };
383     WSRect rect = { 30, 30, 900, 900 };
384     session->SetSessionRect(preRect);
385 
386     session->property_->SetDragEnabled(true);
387     session->SetSurfaceBounds(rect);
388     session->property_->SetDragEnabled(false);
389     session->SetSurfaceBounds(rect);
390     EXPECT_EQ(preRect, session->GetSessionRect());
391 }
392 
393 /**
394  * @tc.name: OnLayoutFullScreenChange
395  * @tc.desc: OnLayoutFullScreenChange function
396  * @tc.type: FUNC
397  */
HWTEST_F(SceneSessionTest5, OnLayoutFullScreenChange, Function | SmallTest | Level2)398 HWTEST_F(SceneSessionTest5, OnLayoutFullScreenChange, Function | SmallTest | Level2)
399 {
400     SessionInfo info;
401     info.abilityName_ = "OnLayoutFullScreenChange";
402     info.bundleName_ = "OnLayoutFullScreenChange";
403     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
404     EXPECT_NE(session, nullptr);
405     EXPECT_EQ(WSError::WS_OK, session->OnLayoutFullScreenChange(true));
406 
407     sptr<SceneSession::SessionChangeCallback> sessionChangeCallback =
408         sptr<SceneSession::SessionChangeCallback>::MakeSptr();
409     session->RegisterSessionChangeCallback(sessionChangeCallback);
410     sessionChangeCallback->onLayoutFullScreenChangeFunc_ = nullptr;
411     EXPECT_EQ(WSError::WS_OK, session->OnLayoutFullScreenChange(true));
412 
413     NotifyLayoutFullScreenChangeFunc func = [](bool isLayoutFullScreen) {
414         return;
415     };
416     sessionChangeCallback->onLayoutFullScreenChangeFunc_ = func;
417     EXPECT_EQ(WSError::WS_OK, session->OnLayoutFullScreenChange(true));
418 }
419 
420 /**
421  * @tc.name: UpdateSessionPropertyByAction
422  * @tc.desc: UpdateSessionPropertyByAction function01
423  * @tc.type: FUNC
424  */
HWTEST_F(SceneSessionTest5, UpdateSessionPropertyByAction, Function | SmallTest | Level2)425 HWTEST_F(SceneSessionTest5, UpdateSessionPropertyByAction, Function | SmallTest | Level2)
426 {
427     SessionInfo info;
428     info.abilityName_ = "UpdateSessionPropertyByAction";
429     info.bundleName_ = "UpdateSessionPropertyByAction";
430     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
431     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
432     EXPECT_NE(session, nullptr);
433     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
434     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, session->UpdateSessionPropertyByAction
435         (nullptr, WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE));
436     EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, session->UpdateSessionPropertyByAction
437         (property, WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE));
438 }
439 
440 /**
441  * @tc.name: SetSessionRectChangeCallback
442  * @tc.desc: SetSessionRectChangeCallback function01
443  * @tc.type: FUNC
444  */
HWTEST_F(SceneSessionTest5, SetSessionRectChangeCallback, Function | SmallTest | Level2)445 HWTEST_F(SceneSessionTest5, SetSessionRectChangeCallback, Function | SmallTest | Level2)
446 {
447     SessionInfo info;
448     info.abilityName_ = "SetSessionRectChangeCallback";
449     info.bundleName_ = "SetSessionRectChangeCallback";
450     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
451     EXPECT_NE(session, nullptr);
452     WSRect rec = { 1, 1, 1, 1 };
453     NotifySessionRectChangeFunc func = [](const WSRect& rect, const SizeChangeReason reason, DisplayId displayId) {
454         return;
455     };
456     session->SetSessionRectChangeCallback(nullptr);
457     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
458     session->SetSessionRectChangeCallback(func);
459     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
460     session->SetSessionRectChangeCallback(func);
461     rec.width_ = 0;
462     session->SetSessionRectChangeCallback(func);
463     rec.height_ = 0;
464     session->SetSessionRectChangeCallback(func);
465     EXPECT_EQ(WindowType::APP_MAIN_WINDOW_BASE, session->GetWindowType());
466 }
467 
468 /**
469  * @tc.name: SetSessionRectChangeCallback02
470  * @tc.desc: SetSessionRectChangeCallback02 function01
471  * @tc.type: FUNC
472  */
HWTEST_F(SceneSessionTest5, SetSessionRectChangeCallback02, Function | SmallTest | Level2)473 HWTEST_F(SceneSessionTest5, SetSessionRectChangeCallback02, Function | SmallTest | Level2)
474 {
475     SessionInfo info;
476     info.abilityName_ = "SetSessionRectChangeCallback02";
477     info.bundleName_ = "SetSessionRectChangeCallback02";
478     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
479     EXPECT_NE(session, nullptr);
480     WSRect rec = { 1, 1, 1, 1 };
481     NotifySessionRectChangeFunc func = [](const WSRect& rect, const SizeChangeReason reason, DisplayId displayId) {
482         return;
483     };
484     session->SetSessionRectChangeCallback(nullptr);
485 
486     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
487     EXPECT_NE(property, nullptr);
488     property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
489     session->SetSessionProperty(property);
490     session->SetSessionRectChangeCallback(func);
491 
492     property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
493     session->SetSessionProperty(property);
494     session->SetSessionRequestRect(rec);
495     session->SetSessionRectChangeCallback(func);
496 
497     rec.width_ = 0;
498     session->SetSessionRequestRect(rec);
499     session->SetSessionRectChangeCallback(func);
500 
501     rec.height_ = 0;
502     session->SetSessionRequestRect(rec);
503     session->SetSessionRectChangeCallback(func);
504     EXPECT_EQ(WindowType::APP_MAIN_WINDOW_BASE, session->GetWindowType());
505 }
506 
507 /**
508  * @tc.name: SetSessionRectChangeCallback03
509  * @tc.desc: SetSessionRectChangeCallback
510  * @tc.type: FUNC
511  */
HWTEST_F(SceneSessionTest5, SetSessionRectChangeCallback03, Function | SmallTest | Level2)512 HWTEST_F(SceneSessionTest5, SetSessionRectChangeCallback03, Function | SmallTest | Level2)
513 {
514     SessionInfo info;
515     info.abilityName_ = "SetSessionRectChangeCallback03";
516     info.bundleName_ = "SetSessionRectChangeCallback03";
517     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
518     property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
519     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
520     session->SetSessionProperty(property);
521     WSRect rec = { 1, 1, 1, 1 };
522     NotifySessionRectChangeFunc func = [](const WSRect& rect, const SizeChangeReason reason, DisplayId displayId) {
523         return;
524     };
525     session->SetSessionRequestRect(rec);
526     session->SetSessionRectChangeCallback(nullptr);
527 
528     rec.width_ = 0;
529     session->SetSessionRequestRect(rec);
530     session->SetSessionRectChangeCallback(nullptr);
531 
532     rec.height_ = 0;
533     rec.width_ = 1;
534     session->SetSessionRequestRect(rec);
535     session->SetSessionRectChangeCallback(nullptr);
536 
537     rec.height_ = 0;
538     rec.width_ = 0;
539     session->SetSessionRequestRect(rec);
540     session->SetSessionRectChangeCallback(nullptr);
541     EXPECT_EQ(WindowType::APP_MAIN_WINDOW_BASE, session->GetWindowType());
542 }
543 
544 /**
545  * @tc.name: NotifyClientToUpdateRect
546  * @tc.desc: NotifyClientToUpdateRect function01
547  * @tc.type: FUNC
548  */
HWTEST_F(SceneSessionTest5, NotifyClientToUpdateRect, Function | SmallTest | Level2)549 HWTEST_F(SceneSessionTest5, NotifyClientToUpdateRect, Function | SmallTest | Level2)
550 {
551     SessionInfo info;
552     info.abilityName_ = "NotifyClientToUpdateRect";
553     info.bundleName_ = "NotifyClientToUpdateRect";
554     info.isSystem_ = false;
555     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
556     EXPECT_NE(session, nullptr);
557     session->moveDragController_ = nullptr;
558     session->isKeyboardPanelEnabled_ = false;
559     session->reason_ = SizeChangeReason::UNDEFINED;
560     session->Session::SetSessionState(SessionState::STATE_CONNECT);
561     session->specificCallback_ = nullptr;
562     session->reason_ = SizeChangeReason::DRAG;
563     EXPECT_EQ(WSError::WS_OK, session->NotifyClientToUpdateRect("SceneSessionTest5", nullptr));
564 
565     UpdateAvoidAreaCallback func = [](const int32_t& persistentId) {
566         return;
567     };
568     sptr<SceneSession::SpecificSessionCallback> specificCallback =
569         sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
570     specificCallback->onUpdateAvoidArea_ = func;
571     session->specificCallback_ = specificCallback;
572     session->reason_ = SizeChangeReason::RECOVER;
573     EXPECT_EQ(WSError::WS_OK, session->NotifyClientToUpdateRect("SceneSessionTest5", nullptr));
574 }
575 
576 /**
577  * @tc.name: CheckAspectRatioValid
578  * @tc.desc: CheckAspectRatioValid function01
579  * @tc.type: FUNC
580  */
HWTEST_F(SceneSessionTest5, CheckAspectRatioValid, Function | SmallTest | Level2)581 HWTEST_F(SceneSessionTest5, CheckAspectRatioValid, Function | SmallTest | Level2)
582 {
583     SessionInfo info;
584     info.abilityName_ = "CheckAspectRatioValid";
585     info.bundleName_ = "CheckAspectRatioValid";
586     info.isSystem_ = false;
587     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
588     EXPECT_NE(session, nullptr);
589     WindowLimits windowLimits;
590     ASSERT_NE(session->GetSessionProperty(), nullptr);
591     session->GetSessionProperty()->SetWindowLimits(windowLimits);
592 
593     SystemSessionConfig systemConfig;
594     systemConfig.isSystemDecorEnable_ = false;
595     session->SetSystemConfig(systemConfig);
596     EXPECT_EQ(false, session->IsDecorEnable());
597 
598     windowLimits.minWidth_ = 0;
599     windowLimits.minHeight_ = 0;
600     EXPECT_EQ(WSError::WS_OK, session->SetAspectRatio(0.0f));
601 
602     windowLimits.minWidth_ = 1;
603     windowLimits.maxHeight_ = 0;
604     windowLimits.minHeight_ = 1;
605     windowLimits.maxWidth_ = 0;
606     EXPECT_EQ(WSError::WS_OK, session->SetAspectRatio(0.0f));
607 
608     windowLimits.maxHeight_ = 1;
609     windowLimits.maxWidth_ = 1;
610     EXPECT_EQ(WSError::WS_OK, session->SetAspectRatio(1.0f));
611 
612     windowLimits.maxHeight_ = 10000;
613     windowLimits.minHeight_ = -10000;
614     EXPECT_EQ(WSError::WS_OK, session->SetAspectRatio(0.0f));
615 
616     windowLimits.maxHeight_ = 10000;
617     windowLimits.minHeight_ = -10000;
618     EXPECT_EQ(WSError::WS_OK, session->SetAspectRatio(0.0f));
619 
620     session->SetSessionProperty(nullptr);
621     EXPECT_EQ(WSError::WS_ERROR_NULLPTR, session->SetAspectRatio(0.0f));
622 
623     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
624     EXPECT_NE(property, nullptr);
625     WindowLimits limits = {8, 1, 6, 1, 1, 1.0f, 1.0f};
626     property->SetWindowLimits(limits);
627     session->SetSessionProperty(property);
628     EXPECT_EQ(WSError::WS_ERROR_INVALID_PARAM, session->SetAspectRatio(0.1f));
629     EXPECT_EQ(WSError::WS_ERROR_INVALID_PARAM, session->SetAspectRatio(10.0f));
630 }
631 
632 /**
633  * @tc.name: CheckAspectRatioValid02
634  * @tc.desc: CheckAspectRatioValid
635  * @tc.type: FUNC
636  */
HWTEST_F(SceneSessionTest5, CheckAspectRatioValid02, Function | SmallTest | Level2)637 HWTEST_F(SceneSessionTest5, CheckAspectRatioValid02, Function | SmallTest | Level2)
638 {
639     SessionInfo info;
640     info.abilityName_ = "CheckAspectRatioValid02";
641     info.bundleName_ = "CheckAspectRatioValid02";
642     info.isSystem_ = false;
643     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
644     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
645     sceneSession->SetSessionProperty(property);
646 
647     WindowLimits windowLimits;
648     ASSERT_NE(sceneSession->GetSessionProperty(), nullptr);
649     sceneSession->GetSessionProperty()->SetWindowLimits(windowLimits);
650 
651     SystemSessionConfig systemConfig;
652     systemConfig.isSystemDecorEnable_ = false;
653     sceneSession->SetSystemConfig(systemConfig);
654     EXPECT_EQ(false, sceneSession->IsDecorEnable());
655 
656     windowLimits.minWidth_ = 0;
657     windowLimits.minHeight_ = 0;
658     EXPECT_EQ(WSError::WS_OK, sceneSession->SetAspectRatio(0.0f));
659 
660     windowLimits.minWidth_ = 1;
661     windowLimits.minHeight_ = 2;
662     EXPECT_EQ(WSError::WS_OK, sceneSession->SetAspectRatio(0.0f));
663 
664     windowLimits.minWidth_ = 2;
665     windowLimits.minHeight_ = 1;
666     EXPECT_EQ(WSError::WS_OK, sceneSession->SetAspectRatio(0.0f));
667 
668     windowLimits.minWidth_ = 1;
669     windowLimits.minHeight_ = 2;
670     EXPECT_EQ(WSError::WS_OK, sceneSession->SetAspectRatio(1.0f));
671 }
672 
673 /**
674  * @tc.name: GetSystemAvoidArea02
675  * @tc.desc: GetSystemAvoidArea02 function
676  * @tc.type: FUNC
677  */
HWTEST_F(SceneSessionTest5, GetSystemAvoidArea02, Function | SmallTest | Level2)678 HWTEST_F(SceneSessionTest5, GetSystemAvoidArea02, Function | SmallTest | Level2)
679 {
680     SessionInfo info;
681     info.abilityName_ = "GetSystemAvoidArea02";
682     info.bundleName_ = "GetSystemAvoidArea02";
683 
684     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
685     EXPECT_NE(session, nullptr);
686     ASSERT_NE(session->GetSessionProperty(), nullptr);
687     session->GetSessionProperty()->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
688     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
689 
690     SystemSessionConfig systemConfig;
691     systemConfig.windowUIType_ = WindowUIType::PHONE_WINDOW;
692     session->SetSystemConfig(systemConfig);
693     ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
694     session->GetSessionProperty()->SetDisplayId(1664);
695     session->Session::SetFloatingScale(0.02f);
696     WSRect rect;
697     AvoidArea avoidArea;
698     session->GetSystemAvoidArea(rect, avoidArea);
699     EXPECT_EQ(0.02f, session->Session::GetFloatingScale());
700 
701     session->Session::SetFloatingScale(0.5f);
702     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
703     session->GetSystemAvoidArea(rect, avoidArea);
704     session->GetSessionProperty()->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
705     rect.height_ = 2;
706     rect.width_ =1 ;
707     session->GetSystemAvoidArea(rect, avoidArea);
708     rect.height_ = 1;
709     session->GetSystemAvoidArea(rect, avoidArea);
710 }
711 
712 /**
713  * @tc.name: FixRectByAspectRatio
714  * @tc.desc: FixRectByAspectRatio function01
715  * @tc.type: FUNC
716  */
HWTEST_F(SceneSessionTest5, FixRectByAspectRatio, Function | SmallTest | Level2)717 HWTEST_F(SceneSessionTest5, FixRectByAspectRatio, Function | SmallTest | Level2)
718 {
719     SessionInfo info;
720     info.abilityName_ = "FixRectByAspectRatio";
721     info.bundleName_ = "FixRectByAspectRatio";
722     info.isSystem_ = false;
723     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
724     EXPECT_NE(session, nullptr);
725     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
726     session->SetSessionProperty(nullptr);
727     WSRect rect;
728     EXPECT_EQ(false, session->FixRectByAspectRatio(rect));
729     session->SetSessionProperty(property);
730     property->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
731     EXPECT_EQ(false, session->FixRectByAspectRatio(rect));
732     property->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
733     property->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
734     EXPECT_EQ(false, session->FixRectByAspectRatio(rect));
735     property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
736     EXPECT_EQ(true, session->FixRectByAspectRatio(rect));
737 }
738 
739 /**
740  * @tc.name: FixRectByAspectRatio01
741  * @tc.desc: FixRectByAspectRatio function01
742  * @tc.type: FUNC
743  */
HWTEST_F(SceneSessionTest5, FixRectByAspectRatio01, Function | SmallTest | Level2)744 HWTEST_F(SceneSessionTest5, FixRectByAspectRatio01, Function | SmallTest | Level2)
745 {
746     SessionInfo info;
747     info.abilityName_ = "FixRectByAspectRatio01";
748     info.bundleName_ = "FixRectByAspectRatio01";
749     info.isSystem_ = false;
750     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
751     EXPECT_NE(session, nullptr);
752     WSRect rect;
753     session->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
754     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
755     session->aspectRatio_ = 0.5f;
756     EXPECT_NE(nullptr, DisplayManager::GetInstance().GetDefaultDisplay());
757 
758     SystemSessionConfig systemConfig;
759     systemConfig.isSystemDecorEnable_ = true;
760     systemConfig.decorModeSupportInfo_ = 2;
761     session->SetSystemConfig(systemConfig);
762     EXPECT_EQ(true, session->FixRectByAspectRatio(rect));
763 
764     systemConfig.isSystemDecorEnable_ = false;
765     EXPECT_EQ(false, session->FixRectByAspectRatio(rect));
766 
767     systemConfig.isSystemDecorEnable_ = true;
768     session->SetSessionProperty(nullptr);
769     EXPECT_EQ(false, session->FixRectByAspectRatio(rect));
770 }
771 
772 /**
773  * @tc.name: OnMoveDragCallback
774  * @tc.desc: OnMoveDragCallback function01
775  * @tc.type: FUNC
776  */
HWTEST_F(SceneSessionTest5, OnMoveDragCallback, Function | SmallTest | Level2)777 HWTEST_F(SceneSessionTest5, OnMoveDragCallback, Function | SmallTest | Level2)
778 {
779     SessionInfo info;
780     info.abilityName_ = "OnMoveDragCallback";
781     info.bundleName_ = "OnMoveDragCallback";
782     info.isSystem_ = false;
783     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
784     EXPECT_NE(session, nullptr);
785     session->moveDragController_ = nullptr;
786     SizeChangeReason reason = { SizeChangeReason::DRAG };
787     session->OnMoveDragCallback(reason);
788     session->moveDragController_ = sptr<MoveDragController>::MakeSptr(2024);
789     session->OnMoveDragCallback(reason);
790 
791     reason = SizeChangeReason::DRAG_END;
792     session->OnMoveDragCallback(reason);
793 
794     reason = SizeChangeReason::MOVE;
795     session->OnMoveDragCallback(reason);
796 
797     reason = SizeChangeReason::DRAG_START;
798     session->OnMoveDragCallback(reason);
799     EXPECT_EQ(WSError::WS_OK, session->UpdateSizeChangeReason(reason));
800 
801     session->moveDragController_ = sptr<MoveDragController>::MakeSptr(2024);
802     EXPECT_NE(session->moveDragController_, nullptr);
803     session->SetSessionProperty(nullptr);
804     session->OnMoveDragCallback(reason);
805     EXPECT_EQ(WSError::WS_OK, session->UpdateSizeChangeReason(reason));
806 
807     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
808     ASSERT_NE(nullptr, property);
809     session->SetSessionProperty(property);
810     property->compatibleModeInPc_ = true;
811     session->OnMoveDragCallback(reason);
812     EXPECT_EQ(WSError::WS_OK, session->UpdateSizeChangeReason(reason));
813 }
814 
815 /**
816  * @tc.name: UpdateWinRectForSystemBar
817  * @tc.desc: UpdateWinRectForSystemBar function01
818  * @tc.type: FUNC
819  */
HWTEST_F(SceneSessionTest5, UpdateWinRectForSystemBar, Function | SmallTest | Level2)820 HWTEST_F(SceneSessionTest5, UpdateWinRectForSystemBar, Function | SmallTest | Level2)
821 {
822     SessionInfo info;
823     info.abilityName_ = "UpdateWinRectForSystemBar";
824     info.bundleName_ = "UpdateWinRectForSystemBar";
825     info.isSystem_ = false;
826     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
827     EXPECT_NE(session, nullptr);
828     sptr<SceneSession::SpecificSessionCallback> specificCallback =
829         sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
830     specificCallback->onGetSceneSessionVectorByType_ = nullptr;
831     session->specificCallback_ = specificCallback;
832     WSRect rect = { 1, 10, 3, 4 };
833     session->UpdateWinRectForSystemBar(rect);
834     GetSceneSessionVectorByTypeCallback func = [session](WindowType type, uint64_t displayId)->
835         std::vector<sptr<SceneSession>>
836     {
837         std::vector<sptr<SceneSession>> vSession;
838         vSession.push_back(session);
839         return vSession;
840     };
841     specificCallback->onGetSceneSessionVectorByType_ = func;
842     session->UpdateWinRectForSystemBar(rect);
843 
844     session->isVisible_ = true;
845     session->winRect_ = rect;
846     session->UpdateWinRectForSystemBar(rect);
847 
848     WSRect rect1 = { 1, 2, 10, 4 };
849     session->winRect_ = rect1;
850     session->UpdateWinRectForSystemBar(rect);
851     EXPECT_EQ(4, session->GetSessionRect().height_);
852 
853     WSRect rect2 = { 1, 2, 10, 8 };
854     session->winRect_ = rect2;
855     session->UpdateWinRectForSystemBar(rect);
856 
857     session->property_ = nullptr;
858     session->UpdateWinRectForSystemBar(rect);
859 }
860 
861 /**
862  * @tc.name: UpdateNativeVisibility
863  * @tc.desc: UpdateNativeVisibility function01
864  * @tc.type: FUNC
865  */
HWTEST_F(SceneSessionTest5, UpdateNativeVisibility, Function | SmallTest | Level2)866 HWTEST_F(SceneSessionTest5, UpdateNativeVisibility, Function | SmallTest | Level2)
867 {
868     SessionInfo info;
869     info.abilityName_ = "UpdateNativeVisibility";
870     info.bundleName_ = "UpdateNativeVisibility";
871     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
872     EXPECT_NE(session, nullptr);
873     sptr<SceneSession::SpecificSessionCallback> specificCallback =
874         sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
875     NotifyWindowInfoUpdateCallback dateFunc = [](int32_t persistentId, WindowUpdateType type) {
876         return;
877     };
878     UpdateAvoidAreaCallback areaFunc = [](const int32_t persistentId) {
879         return;
880     };
881     specificCallback->onWindowInfoUpdate_ = dateFunc;
882     specificCallback->onUpdateAvoidArea_ = areaFunc;
883     session->specificCallback_ = specificCallback;
884     session->UpdateNativeVisibility(true);
885     session->SetSessionProperty(nullptr);
886     session->UpdateNativeVisibility(false);
887     EXPECT_EQ(nullptr, session->property_);
888 }
889 
890 /**
891  * @tc.name: SetPrivacyMode
892  * @tc.desc: SetPrivacyMode function01
893  * @tc.type: FUNC
894  */
HWTEST_F(SceneSessionTest5, SetPrivacyMode, Function | SmallTest | Level2)895 HWTEST_F(SceneSessionTest5, SetPrivacyMode, Function | SmallTest | Level2)
896 {
897     SessionInfo info;
898     info.abilityName_ = "SetPrivacyMode";
899     info.bundleName_ = "SetPrivacyMode";
900     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
901     EXPECT_NE(session, nullptr);
902     struct RSSurfaceNodeConfig config;
903     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
904     session->surfaceNode_ = surfaceNode;
905     ASSERT_NE(session->GetSessionProperty(), nullptr);
906     session->GetSessionProperty()->SetPrivacyMode(true);
907     EXPECT_EQ(true, session->GetSessionProperty()->GetPrivacyMode());
908     session->leashWinSurfaceNode_ = nullptr;
909     session->SetPrivacyMode(false);
910     session->leashWinSurfaceNode_ = surfaceNode;
911     session->SetPrivacyMode(true);
912     session->SetSessionProperty(nullptr);
913     session->SetPrivacyMode(true);
914 
915     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
916     EXPECT_NE(property, nullptr);
917     property->SetPrivacyMode(true);
918     session->SetSessionProperty(property);
919     session->SetPrivacyMode(true);
920 }
921 
922 /**
923  * @tc.name: SetSnapshotSkip
924  * @tc.desc: SetSnapshotSkip function01
925  * @tc.type: FUNC
926  */
HWTEST_F(SceneSessionTest5, SetSnapshotSkip, Function | SmallTest | Level2)927 HWTEST_F(SceneSessionTest5, SetSnapshotSkip, Function | SmallTest | Level2)
928 {
929     SessionInfo info;
930     info.abilityName_ = "SetSnapshotSkip";
931     info.bundleName_ = "SetSnapshotSkip";
932     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
933     EXPECT_NE(session, nullptr);
934     struct RSSurfaceNodeConfig config;
935     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
936     session->surfaceNode_ = surfaceNode;
937     ASSERT_NE(session->GetSessionProperty(), nullptr);
938     session->GetSessionProperty()->SetSnapshotSkip(true);
939     EXPECT_EQ(true, session->GetSessionProperty()->GetSnapshotSkip());
940     session->leashWinSurfaceNode_ = nullptr;
941     session->SetSnapshotSkip(false);
942     session->leashWinSurfaceNode_ = surfaceNode;
943     session->SetSnapshotSkip(false);
944     session->SetSnapshotSkip(true);
945     session->surfaceNode_ = nullptr;
946     EXPECT_NE(nullptr, session->GetLeashWinSurfaceNode());
947     session->SetSnapshotSkip(true);
948     session->SetSessionProperty(nullptr);
949     session->SetSnapshotSkip(true);
950     EXPECT_EQ(nullptr, session->GetSessionProperty());
951 }
952 
953 /**
954  * @tc.name: SetWatermarkEnabled
955  * @tc.desc: SetWatermarkEnabled function01
956  * @tc.type: FUNC
957  */
HWTEST_F(SceneSessionTest5, SetWatermarkEnabled, Function | SmallTest | Level2)958 HWTEST_F(SceneSessionTest5, SetWatermarkEnabled, Function | SmallTest | Level2)
959 {
960     SessionInfo info;
961     info.abilityName_ = "SetWatermarkEnabled";
962     info.bundleName_ = "SetWatermarkEnabled";
963     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
964     EXPECT_NE(session, nullptr);
965 
966     std::string watermarkName = "watermarkNameTest";
967     session->SetWatermarkEnabled(watermarkName, true);
968 
969     struct RSSurfaceNodeConfig config;
970     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
971     session->surfaceNode_ = surfaceNode;
972     session->SetWatermarkEnabled(watermarkName, true);
973 }
974 
975 /**
976  * @tc.name: UIExtSurfaceNodeIdCache
977  * @tc.desc: UIExtSurfaceNodeIdCache
978  * @tc.type: FUNC
979  */
HWTEST_F(SceneSessionTest5, UIExtSurfaceNodeIdCache, Function | SmallTest | Level2)980 HWTEST_F(SceneSessionTest5, UIExtSurfaceNodeIdCache, Function | SmallTest | Level2)
981 {
982     SessionInfo info;
983     info.abilityName_ = "UIExtSurfaceNodeIdCache";
984     info.bundleName_ = "UIExtSurfaceNodeIdCache";
985     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
986     EXPECT_NE(session, nullptr);
987 
988     session->AddUIExtSurfaceNodeId(1, 2);
989     EXPECT_EQ(session->GetUIExtPersistentIdBySurfaceNodeId(1), 2);
990 
991     session->RemoveUIExtSurfaceNodeId(2);
992     EXPECT_EQ(session->GetUIExtPersistentIdBySurfaceNodeId(1), 0);
993 }
994 
995 /**
996  * @tc.name: SetSystemSceneOcclusionAlpha
997  * @tc.desc: SetSystemSceneOcclusionAlpha function01
998  * @tc.type: FUNC
999  */
HWTEST_F(SceneSessionTest5, SetSystemSceneOcclusionAlpha, Function | SmallTest | Level2)1000 HWTEST_F(SceneSessionTest5, SetSystemSceneOcclusionAlpha, Function | SmallTest | Level2)
1001 {
1002     SessionInfo info;
1003     info.abilityName_ = "SetSystemSceneOcclusionAlpha";
1004     info.bundleName_ = "SetSystemSceneOcclusionAlpha";
1005     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1006     EXPECT_NE(session, nullptr);
1007     session->SetSystemSceneOcclusionAlpha(-0.325);
1008     session->SetSystemSceneOcclusionAlpha(3.14125);
1009 
1010     struct RSSurfaceNodeConfig config;
1011     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
1012     session->surfaceNode_ = surfaceNode;
1013     session->leashWinSurfaceNode_ = nullptr;
1014     session->SetSystemSceneOcclusionAlpha(0.14125);
1015     session->leashWinSurfaceNode_ = surfaceNode;
1016     session->SetSystemSceneOcclusionAlpha(0.14125);
1017     EXPECT_NE(nullptr, session->GetLeashWinSurfaceNode());
1018 }
1019 
1020 /**
1021  * @tc.name: SetSystemSceneForceUIFirst
1022  * @tc.desc: SetSystemSceneForceUIFirst function01
1023  * @tc.type: FUNC
1024  */
HWTEST_F(SceneSessionTest5, SetSystemSceneForceUIFirst, Function | SmallTest | Level2)1025 HWTEST_F(SceneSessionTest5, SetSystemSceneForceUIFirst, Function | SmallTest | Level2)
1026 {
1027     SessionInfo info;
1028     info.abilityName_ = "SetSystemSceneForceUIFirst";
1029     info.bundleName_ = "SetSystemSceneForceUIFirst";
1030     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1031     EXPECT_NE(session, nullptr);
1032     session->SetSystemSceneForceUIFirst(true);
1033 
1034     struct RSSurfaceNodeConfig config;
1035     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
1036     session->surfaceNode_ = surfaceNode;
1037     session->leashWinSurfaceNode_ = nullptr;
1038     session->SetSystemSceneForceUIFirst(true);
1039     session->leashWinSurfaceNode_ = surfaceNode;
1040     session->SetSystemSceneForceUIFirst(true);
1041     EXPECT_NE(nullptr, session->GetLeashWinSurfaceNode());
1042 }
1043 
1044 /**
1045  * @tc.name: UpdateWindowAnimationFlag
1046  * @tc.desc: UpdateWindowAnimationFlag function01
1047  * @tc.type: FUNC
1048  */
HWTEST_F(SceneSessionTest5, UpdateWindowAnimationFlag, Function | SmallTest | Level2)1049 HWTEST_F(SceneSessionTest5, UpdateWindowAnimationFlag, Function | SmallTest | Level2)
1050 {
1051     SessionInfo info;
1052     info.abilityName_ = "UpdateWindowAnimationFlag";
1053     info.bundleName_ = "UpdateWindowAnimationFlag";
1054     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1055     EXPECT_NE(session, nullptr);
1056 
1057     sptr<SceneSession::SessionChangeCallback> sessionChangeCallback =
1058         sptr<SceneSession::SessionChangeCallback>::MakeSptr();
1059     session->RegisterSessionChangeCallback(nullptr);
1060     EXPECT_EQ(WSError::WS_OK, session->UpdateWindowAnimationFlag(true));
1061 
1062     sessionChangeCallback->onWindowAnimationFlagChange_ = nullptr;
1063     session->RegisterSessionChangeCallback(sessionChangeCallback);
1064     EXPECT_EQ(WSError::WS_OK, session->UpdateWindowAnimationFlag(true));
1065 
1066     NotifyWindowAnimationFlagChangeFunc func = [](const bool flag) {
1067         return;
1068     };
1069     sessionChangeCallback->onWindowAnimationFlagChange_ = func;
1070     EXPECT_EQ(WSError::WS_OK, session->UpdateWindowAnimationFlag(true));
1071 }
1072 
1073 /**
1074  * @tc.name: SetForegroundInteractiveStatus
1075  * @tc.desc: SetForegroundInteractiveStatus function01
1076  * @tc.type: FUNC
1077  */
HWTEST_F(SceneSessionTest5, SetForegroundInteractiveStatus, Function | SmallTest | Level2)1078 HWTEST_F(SceneSessionTest5, SetForegroundInteractiveStatus, Function | SmallTest | Level2)
1079 {
1080     SessionInfo info;
1081     info.abilityName_ = "SetForegroundInteractiveStatus";
1082     info.bundleName_ = "SetForegroundInteractiveStatus";
1083     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1084     session->SetSessionState(SessionState::STATE_FOREGROUND);
1085     EXPECT_NE(session, nullptr);
1086     session->toastSession_.clear();
1087     session->toastSession_.push_back(session);
1088     session->SetForegroundInteractiveStatus(false);
1089     session->toastSession_.clear();
1090     session->SetSessionState(SessionState::STATE_ACTIVE);
1091     session->toastSession_.push_back(session);
1092     session->SetForegroundInteractiveStatus(false);
1093     session->toastSession_.clear();
1094     session->SetSessionState(SessionState::STATE_CONNECT);
1095     session->toastSession_.push_back(session);
1096     session->SetForegroundInteractiveStatus(false);
1097     session->toastSession_.clear();
1098     session->SetSessionState(SessionState::STATE_ACTIVE);
1099     session->toastSession_.push_back(nullptr);
1100     session->SetForegroundInteractiveStatus(false);
1101     session->toastSession_.clear();
1102 }
1103 
1104 /**
1105  * @tc.name: HandleUpdatePropertyByAction
1106  * @tc.desc: HandleUpdatePropertyByAction function01
1107  * @tc.type: FUNC
1108  */
HWTEST_F(SceneSessionTest5, HandleUpdatePropertyByAction, Function | SmallTest | Level2)1109 HWTEST_F(SceneSessionTest5, HandleUpdatePropertyByAction, Function | SmallTest | Level2)
1110 {
1111     SessionInfo info;
1112     info.abilityName_ = "HandleUpdatePropertyByAction";
1113     info.bundleName_ = "HandleUpdatePropertyByAction";
1114     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1115     ASSERT_NE(nullptr, session);
1116     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_RECT;
1117     auto res = session->HandleUpdatePropertyByAction(nullptr, action);
1118     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
1119     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1120     ASSERT_NE(nullptr, property);
1121     res = session->HandleUpdatePropertyByAction(property, action);
1122     EXPECT_EQ(WMError::WM_DO_NOTHING, res);
1123     action = WSPropertyChangeAction::ACTION_UPDATE_FLAGS;
1124     res = session->HandleUpdatePropertyByAction(property, action);
1125     EXPECT_EQ(WMError::WM_OK, res);
1126 }
1127 
1128 /**
1129  * @tc.name: SetSystemWindowEnableDrag
1130  * @tc.desc: SetSystemWindowEnableDrag function01
1131  * @tc.type: FUNC
1132  */
HWTEST_F(SceneSessionTest5, SetSystemWindowEnableDrag, Function | SmallTest | Level2)1133 HWTEST_F(SceneSessionTest5, SetSystemWindowEnableDrag, Function | SmallTest | Level2)
1134 {
1135     SessionInfo info;
1136     info.abilityName_ = "SetSystemWindowEnableDrag";
1137     info.bundleName_ = "SetSystemWindowEnableDrag";
1138     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_DESKTOP);
1139     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1140     auto ret = session->SetSystemWindowEnableDrag(true);
1141     EXPECT_EQ(WMError::WM_OK, ret);
1142 }
1143 
1144 /**
1145  * @tc.name: HandleActionUpdateSetBrightness
1146  * @tc.desc: HandleActionUpdateSetBrightness function01
1147  * @tc.type: FUNC
1148  */
HWTEST_F(SceneSessionTest5, HandleActionUpdateSetBrightness, Function | SmallTest | Level2)1149 HWTEST_F(SceneSessionTest5, HandleActionUpdateSetBrightness, Function | SmallTest | Level2)
1150 {
1151     SessionInfo info;
1152     info.abilityName_ = "HandleActionUpdateSetBrightness";
1153     info.bundleName_ = "HandleActionUpdateSetBrightness";
1154     info.windowType_ = static_cast<uint32_t>(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
1155     info.isSystem_ = true;
1156     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1157     ASSERT_NE(nullptr, session);
1158     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1159     ASSERT_NE(nullptr, property);
1160     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_RECT;
1161     auto res = session->HandleActionUpdateSetBrightness(property, action);
1162     EXPECT_EQ(WMError::WM_OK, res);
1163 
1164     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1165     sptr<SceneSession> session1 = sptr<SceneSession>::MakeSptr(info, nullptr);
1166     res = session1->HandleActionUpdateSetBrightness(property, action);
1167     EXPECT_EQ(WMError::WM_ERROR_INVALID_SESSION, res);
1168 
1169     info.isSystem_ = false;
1170     sptr<SceneSession> session2 = sptr<SceneSession>::MakeSptr(info, nullptr);
1171     session2->SetSessionState(SessionState::STATE_CONNECT);
1172     res = session2->HandleActionUpdateSetBrightness(property, action);
1173     EXPECT_EQ(WMError::WM_OK, res);
1174 
1175     sptr<SceneSession> session3 = sptr<SceneSession>::MakeSptr(info, nullptr);
1176     session3->SetSessionState(SessionState::STATE_CONNECT);
1177     float brightness = 1.0;
1178     property->SetBrightness(brightness);
1179     EXPECT_EQ(brightness, property->GetBrightness());
1180     EXPECT_EQ(WSError::WS_OK, session3->SetBrightness(brightness));
1181     res = session3->HandleActionUpdateSetBrightness(property, action);
1182     EXPECT_EQ(WMError::WM_OK, res);
1183     EXPECT_EQ(brightness, session3->GetBrightness());
1184 
1185     sptr<SceneSession> session4 = sptr<SceneSession>::MakeSptr(info, nullptr);
1186     session4->SetSessionState(SessionState::STATE_CONNECT);
1187     brightness = 0.8;
1188     property->SetBrightness(brightness);
1189     EXPECT_EQ(brightness, property->GetBrightness());
1190     res = session4->HandleActionUpdateSetBrightness(property, action);
1191     EXPECT_EQ(WMError::WM_OK, res);
1192     EXPECT_EQ(brightness, session4->GetBrightness());
1193     brightness = 1.0;
1194     EXPECT_EQ(WSError::WS_OK, session4->SetBrightness(brightness));
1195     EXPECT_EQ(brightness, session4->GetBrightness());
1196 }
1197 
1198 /**
1199  * @tc.name: HandleActionUpdateMaximizeState
1200  * @tc.desc: HandleActionUpdateMaximizeState function01
1201  * @tc.type: FUNC
1202  */
HWTEST_F(SceneSessionTest5, HandleActionUpdateMaximizeState, Function | SmallTest | Level2)1203 HWTEST_F(SceneSessionTest5, HandleActionUpdateMaximizeState, Function | SmallTest | Level2)
1204 {
1205     SessionInfo info;
1206     info.abilityName_ = "HandleActionUpdateMaximizeState";
1207     info.bundleName_ = "HandleActionUpdateMaximizeState";
1208     info.windowType_ = static_cast<uint32_t>(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
1209     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1210     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1211     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_RECT;
1212 
1213     auto res = session->HandleActionUpdateMaximizeState(property, action);
1214     EXPECT_EQ(WMError::WM_OK, res);
1215     res = session->HandleActionUpdateMode(property, action);
1216     EXPECT_EQ(WMError::WM_OK, res);
1217     res = session->HandleActionUpdateAnimationFlag(property, action);
1218     EXPECT_EQ(WMError::WM_OK, res);
1219 
1220     session->SetSessionProperty(nullptr);
1221     res = session->HandleActionUpdateMaximizeState(property, action);
1222     EXPECT_EQ(WMError::WM_OK, res);
1223     res = session->HandleActionUpdateMode(property, action);
1224     EXPECT_EQ(WMError::WM_OK, res);
1225     res = session->HandleActionUpdateAnimationFlag(property, action);
1226     EXPECT_EQ(WMError::WM_OK, res);
1227 }
1228 
1229 /**
1230  * @tc.name: SetUniqueDensityDpi
1231  * @tc.desc: SetUniqueDensityDpi function01
1232  * @tc.type: FUNC
1233  */
HWTEST_F(SceneSessionTest5, SetUniqueDensityDpi, Function | SmallTest | Level2)1234 HWTEST_F(SceneSessionTest5, SetUniqueDensityDpi, Function | SmallTest | Level2)
1235 {
1236     SessionInfo info;
1237     info.abilityName_ = "SetUniqueDensityDpi";
1238     info.bundleName_ = "SetUniqueDensityDpi";
1239     info.windowType_ = static_cast<uint32_t>(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
1240     info.isSystem_ = true;
1241     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1242     EXPECT_NE(session, nullptr);
1243     session->sessionStage_ = nullptr;
1244     EXPECT_EQ(WMError::WM_ERROR_INVALID_SESSION, session->SetUniqueDensityDpi(true, 520));
1245     session->sessionInfo_.isSystem_ = false;
1246     session->state_ = SessionState::STATE_DISCONNECT;
1247     EXPECT_EQ(WMError::WM_ERROR_INVALID_SESSION, session->SetUniqueDensityDpi(true, 520));
1248     session->state_ = SessionState::STATE_CONNECT;
1249     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, session->SetUniqueDensityDpi(true, 520));
1250     EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, session->SetUniqueDensityDpi(true, 79));
1251     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, session->SetUniqueDensityDpi(false, 79));
1252 
1253     session->sessionStage_ = new SessionStageMocker();
1254     EXPECT_NE(nullptr, session->sessionStage_);
1255 }
1256 
1257 /**
1258  * @tc.name: HandleActionUpdateModeSupportInfo
1259  * @tc.desc: HandleActionUpdateModeSupportInfo function01
1260  * @tc.type: FUNC
1261  */
HWTEST_F(SceneSessionTest5, HandleActionUpdateModeSupportInfo, Function | SmallTest | Level2)1262 HWTEST_F(SceneSessionTest5, HandleActionUpdateModeSupportInfo, Function | SmallTest | Level2)
1263 {
1264     SessionInfo info;
1265     info.abilityName_ = "HandleActionUpdateModeSupportInfo";
1266     info.bundleName_ = "HandleActionUpdateModeSupportInfo";
1267     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1268     ASSERT_NE(session, nullptr);
1269     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1270     property->isSystemCalling_ = true;
1271     ASSERT_NE(session, nullptr);
1272     session->SetSessionProperty(nullptr);
1273     ASSERT_EQ(WMError::WM_OK, session->HandleActionUpdateModeSupportInfo(property,
1274         WSPropertyChangeAction::ACTION_UPDATE_RECT));
1275 
1276     property->isSystemCalling_ = false;
1277     session->SetSessionProperty(property);
1278     ASSERT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, session->HandleActionUpdateModeSupportInfo(property,
1279         WSPropertyChangeAction::ACTION_UPDATE_RECT));
1280 }
1281 
1282 /**
1283  * @tc.name: UpdateUIParam
1284  * @tc.desc: UpdateUIParam function01
1285  * @tc.type: FUNC
1286  */
HWTEST_F(SceneSessionTest5, UpdateUIParam, Function | SmallTest | Level2)1287 HWTEST_F(SceneSessionTest5, UpdateUIParam, Function | SmallTest | Level2)
1288 {
1289     SessionInfo info;
1290     info.abilityName_ = "UpdateUIParam";
1291     info.bundleName_ = "UpdateUIParam";
1292     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1293     ASSERT_NE(session, nullptr);
1294     session->isFocused_ = true;
1295     session->isVisible_ = false;
1296     uint32_t res = session->UpdateUIParam();
1297     ASSERT_EQ(0, res);
1298     ASSERT_EQ(false, session->postProcessFocusState_.enabled_);
1299 
1300     session->isFocused_ = true;
1301     session->isVisible_ = true;
1302     uint32_t res1 = session->UpdateUIParam();
1303     ASSERT_EQ(1, res1);
1304     ASSERT_EQ(true, session->postProcessFocusState_.enabled_);
1305 }
1306 
1307 /**
1308  * @tc.name: UpdateVisibilityInner
1309  * @tc.desc: UpdateVisibilityInner function01
1310  * @tc.type: FUNC
1311  */
HWTEST_F(SceneSessionTest5, UpdateVisibilityInner, Function | SmallTest | Level2)1312 HWTEST_F(SceneSessionTest5, UpdateVisibilityInner, Function | SmallTest | Level2)
1313 {
1314     SessionInfo info;
1315     info.abilityName_ = "UpdateVisibilityInner";
1316     info.bundleName_ = "UpdateVisibilityInner";
1317     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1318     ASSERT_NE(session, nullptr);
1319     session->isVisible_ = true;
1320     ASSERT_EQ(false, session->UpdateVisibilityInner(true));
1321 }
1322 
1323 /**
1324  * @tc.name: UpdateInteractiveInner
1325  * @tc.desc: UpdateInteractiveInner function01
1326  * @tc.type: FUNC
1327  */
HWTEST_F(SceneSessionTest5, UpdateInteractiveInner, Function | SmallTest | Level2)1328 HWTEST_F(SceneSessionTest5, UpdateInteractiveInner, Function | SmallTest | Level2)
1329 {
1330     SessionInfo info;
1331     info.abilityName_ = "UpdateInteractiveInner";
1332     info.bundleName_ = "UpdateInteractiveInner";
1333     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1334     ASSERT_NE(session, nullptr);
1335     session->foregroundInteractiveStatus_.store(true);
1336     ASSERT_EQ(false, session->UpdateInteractiveInner(true));
1337     ASSERT_EQ(true, session->UpdateInteractiveInner(false));
1338 }
1339 
1340 /**
1341  * @tc.name: IsAnco
1342  * @tc.desc: IsAnco function01
1343  * @tc.type: FUNC
1344  */
HWTEST_F(SceneSessionTest5, IsAnco, Function | SmallTest | Level2)1345 HWTEST_F(SceneSessionTest5, IsAnco, Function | SmallTest | Level2)
1346 {
1347     SessionInfo info;
1348     info.abilityName_ = "IsAnco";
1349     info.bundleName_ = "IsAnco";
1350     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1351     EXPECT_NE(session, nullptr);
1352     bool res = session->IsAnco();
1353     EXPECT_EQ(res, false);
1354 
1355     session->collaboratorType_ = CollaboratorType::RESERVE_TYPE;
1356     res = session->IsAnco();
1357     EXPECT_EQ(res, true);
1358 }
1359 
1360 /**
1361  * @tc.name: ProcessUpdatePropertyByAction
1362  * @tc.desc: ProcessUpdatePropertyByAction function01
1363  * @tc.type: FUNC
1364  */
HWTEST_F(SceneSessionTest5, ProcessUpdatePropertyByAction, Function | SmallTest | Level2)1365 HWTEST_F(SceneSessionTest5, ProcessUpdatePropertyByAction, Function | SmallTest | Level2)
1366 {
1367     SessionInfo info;
1368     info.abilityName_ = "ProcessUpdatePropertyByAction";
1369     info.bundleName_ = "ProcessUpdatePropertyByAction";
1370     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1371     EXPECT_NE(session, nullptr);
1372 
1373     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1374     EXPECT_NE(property, nullptr);
1375 
1376     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_KEEP_SCREEN_ON);
1377     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_FOCUSABLE);
1378     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_TOUCHABLE);
1379     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS);
1380     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_ORIENTATION);
1381     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE);
1382     session->ProcessUpdatePropertyByAction(
1383         property, WSPropertyChangeAction::ACTION_UPDATE_SYSTEM_PRIVACY_MODE);
1384     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_SNAPSHOT_SKIP);
1385     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_MAXIMIZE_STATE);
1386     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_OTHER_PROPS);
1387     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_STATUS_PROPS);
1388     session->ProcessUpdatePropertyByAction(
1389         property, WSPropertyChangeAction::ACTION_UPDATE_NAVIGATION_INDICATOR_PROPS);
1390     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_FLAGS);
1391     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_MODE);
1392     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_ANIMATION_FLAG);
1393     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_TOUCH_HOT_AREA);
1394     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_DECOR_ENABLE);
1395     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_WINDOW_LIMITS);
1396     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_DRAGENABLED);
1397     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_RAISEENABLED);
1398     session->ProcessUpdatePropertyByAction(
1399         property, WSPropertyChangeAction::ACTION_UPDATE_HIDE_NON_SYSTEM_FLOATING_WINDOWS);
1400     session->ProcessUpdatePropertyByAction(
1401         property, WSPropertyChangeAction::ACTION_UPDATE_TEXTFIELD_AVOID_INFO);
1402     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_WINDOW_MASK);
1403     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_TOPMOST);
1404     session->ProcessUpdatePropertyByAction(property, WSPropertyChangeAction::ACTION_UPDATE_MODE_SUPPORT_INFO);
1405 }
1406 
1407 /**
1408  * @tc.name: HandleActionUpdateTurnScreenOn
1409  * @tc.desc: HandleActionUpdateTurnScreenOn function01
1410  * @tc.type: FUNC
1411  */
HWTEST_F(SceneSessionTest5, HandleActionUpdateTurnScreenOn, Function | SmallTest | Level2)1412 HWTEST_F(SceneSessionTest5, HandleActionUpdateTurnScreenOn, Function | SmallTest | Level2)
1413 {
1414     SessionInfo info;
1415     info.abilityName_ = "HandleActionUpdateTurnScreenOn";
1416     info.bundleName_ = "HandleActionUpdateTurnScreenOn";
1417     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1418     EXPECT_NE(session, nullptr);
1419 
1420     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1421     EXPECT_NE(property, nullptr);
1422 
1423     auto res = session->HandleActionUpdateTurnScreenOn(
1424         property, WSPropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON);
1425     EXPECT_EQ(res, WMError::WM_OK);
1426 
1427     property->SetTurnScreenOn(true);
1428     res = session->HandleActionUpdateTurnScreenOn(
1429         property, WSPropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON);
1430     EXPECT_EQ(res, WMError::WM_OK);
1431 }
1432 
1433 /**
1434  * @tc.name: HandleActionUpdatePrivacyMode1
1435  * @tc.desc: HandleActionUpdatePrivacyMode1
1436  * @tc.type: FUNC
1437  */
HWTEST_F(SceneSessionTest5, HandleActionUpdatePrivacyMode1, Function | SmallTest | Level2)1438 HWTEST_F(SceneSessionTest5, HandleActionUpdatePrivacyMode1, Function | SmallTest | Level2)
1439 {
1440     SessionInfo info;
1441     info.abilityName_ = "HandleActionUpdatePrivacyMode1";
1442     info.bundleName_ = "HandleActionUpdatePrivacyMode1";
1443     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
1444     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1445     EXPECT_NE(session, nullptr);
1446     EXPECT_NE(session->property_, nullptr);
1447     struct RSSurfaceNodeConfig config;
1448     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
1449     session->surfaceNode_ = surfaceNode;
1450     session->property_->SetPrivacyMode(false);
1451     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1452     property->SetPrivacyMode(true);
1453     auto res =
1454         session->HandleActionUpdatePrivacyMode(property, WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE);
1455     EXPECT_EQ(WMError::WM_OK, res);
1456     EXPECT_EQ(true, session->property_->GetPrivacyMode());
1457 }
1458 
1459 /**
1460  * @tc.name: HandleActionUpdatePrivacyMode2
1461  * @tc.desc: HandleActionUpdatePrivacyMode2
1462  * @tc.type: FUNC
1463  */
HWTEST_F(SceneSessionTest5, HandleActionUpdatePrivacyMode2, Function | SmallTest | Level2)1464 HWTEST_F(SceneSessionTest5, HandleActionUpdatePrivacyMode2, Function | SmallTest | Level2)
1465 {
1466     SessionInfo info;
1467     info.abilityName_ = "HandleActionUpdatePrivacyMode2";
1468     info.bundleName_ = "HandleActionUpdatePrivacyMode2";
1469     info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
1470     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1471     EXPECT_NE(session, nullptr);
1472     EXPECT_NE(session->property_, nullptr);
1473     struct RSSurfaceNodeConfig config;
1474     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
1475     session->surfaceNode_ = surfaceNode;
1476     session->property_->SetPrivacyMode(true);
1477     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1478     property->SetPrivacyMode(false);
1479     auto res =
1480         session->HandleActionUpdatePrivacyMode(property, WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE);
1481     EXPECT_EQ(WMError::WM_OK, res);
1482     EXPECT_EQ(false, session->property_->GetPrivacyMode());
1483 }
1484 
1485 /**
1486  * @tc.name: UpdateClientRect01
1487  * @tc.desc: UpdateClientRect
1488  * @tc.type: FUNC
1489  */
HWTEST_F(SceneSessionTest5, UpdateClientRect01, Function | SmallTest | Level2)1490 HWTEST_F(SceneSessionTest5, UpdateClientRect01, Function | SmallTest | Level2)
1491 {
1492     SessionInfo info;
1493     info.abilityName_ = "UpdateClientRect01";
1494     info.bundleName_ = "UpdateClientRect01";
1495     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1496     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1497 
1498     WSRect rect = { 0, 0, 0, 0 };
1499     EXPECT_EQ(session->UpdateClientRect(rect), WSError::WS_OK);
1500 
1501     session->SetClientRect(rect);
1502     rect.posX_ = 100;
1503     rect.posY_ = 100;
1504     rect.width_ = 800;
1505     rect.height_ = 800;
1506     EXPECT_EQ(session->UpdateClientRect(rect), WSError::WS_OK);
1507 
1508     session->SetClientRect(rect);
1509     EXPECT_EQ(session->UpdateClientRect(rect), WSError::WS_OK);
1510 }
1511 
1512 /**
1513  * @tc.name: UpdateRect01
1514  * @tc.desc: UpdateRect
1515  * @tc.type: FUNC
1516  */
HWTEST_F(SceneSessionTest5, UpdateRect01, Function | SmallTest | Level2)1517 HWTEST_F(SceneSessionTest5, UpdateRect01, Function | SmallTest | Level2)
1518 {
1519     SessionInfo info;
1520     info.abilityName_ = "UpdateRect01";
1521     info.bundleName_ = "UpdateRect01";
1522     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1523     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1524     EXPECT_NE(session->property_, nullptr);
1525     SizeChangeReason reason = SizeChangeReason::UNDEFINED;
1526 
1527     WSRect rect = { 200, 200, 200, 200 };
1528     session->winRect_ = rect;
1529     session->SetClientRect(rect);
1530     EXPECT_EQ(session->UpdateRect(rect, reason, "SceneSessionTest5"), WSError::WS_OK);
1531 
1532     rect.posX_ = 100;
1533     rect.posY_ = 100;
1534     rect.width_ = 800;
1535     rect.height_ = 800;
1536     session->winRect_ = rect;
1537     EXPECT_EQ(session->UpdateRect(rect, reason, "SceneSessionTest5"), WSError::WS_OK);
1538 }
1539 
1540 /**
1541  * @tc.name: HandleMoveDragSurfaceNode
1542  * @tc.desc: HandleMoveDragSurfaceNode Test
1543  * @tc.type: FUNC
1544  */
HWTEST_F(SceneSessionTest5, HandleMoveDragSurfaceNode, Function | SmallTest | Level2)1545 HWTEST_F(SceneSessionTest5, HandleMoveDragSurfaceNode, Function | SmallTest | Level2)
1546 {
1547     SessionInfo info;
1548     info.abilityName_ = "HandleMoveDragSurfaceNode";
1549     info.bundleName_ = "HandleMoveDragSurfaceNode";
1550     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1551     EXPECT_NE(session, nullptr);
1552 
1553     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1554     EXPECT_NE(property, nullptr);
1555 
1556     session->moveDragController_ = sptr<MoveDragController>::MakeSptr(2024);
1557     EXPECT_NE(session->moveDragController_, nullptr);
1558 
1559     session->HandleMoveDragSurfaceNode(SizeChangeReason::DRAG_START);
1560     session->HandleMoveDragSurfaceNode(SizeChangeReason::DRAG);
1561     session->HandleMoveDragSurfaceNode(SizeChangeReason::MOVE);
1562     session->HandleMoveDragSurfaceNode(SizeChangeReason::DRAG_END);
1563 }
1564 
1565 /**
1566  * @tc.name: SetNotifyVisibleChangeFunc
1567  * @tc.desc: SetNotifyVisibleChangeFunc Test
1568  * @tc.type: FUNC
1569  */
HWTEST_F(SceneSessionTest5, SetNotifyVisibleChangeFunc, Function | SmallTest | Level2)1570 HWTEST_F(SceneSessionTest5, SetNotifyVisibleChangeFunc, Function | SmallTest | Level2)
1571 {
1572     SessionInfo info;
1573     info.abilityName_ = "test";
1574     info.bundleName_ = "test";
1575     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
1576     EXPECT_NE(session, nullptr);
1577 
1578     session->SetNotifyVisibleChangeFunc([](int32_t persistentId) {});
1579     EXPECT_NE(session->notifyVisibleChangeFunc_, nullptr);
1580 }
1581 }
1582 }
1583 }