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 #include <gtest/gtest.h>
16 
17 #include "display_manager.h"
18 #include "input_event.h"
19 #include "key_event.h"
20 #include "mock/mock_session_stage.h"
21 #include "pointer_event.h"
22 
23 #include "session/host/include/main_session.h"
24 #include "session/host/include/scene_session.h"
25 #include "session/host/include/sub_session.h"
26 #include "session/host/include/system_session.h"
27 #include "window_helper.h"
28 #include "wm_common.h"
29 #include "ui/rs_surface_node.h"
30 
31 
32 using namespace testing;
33 using namespace testing::ext;
34 namespace OHOS {
35 namespace Rosen {
36 class SceneSessionTest4 : public testing::Test {
37 public:
38     static void SetUpTestCase();
39     static void TearDownTestCase();
40     void SetUp() override;
41     void TearDown() override;
42     sptr<SceneSession> sceneSession;
43     sptr<WindowSessionProperty> property;
44     SessionInfo info;
45     WSPropertyChangeAction action;
46 };
47 
SetUpTestCase()48 void SceneSessionTest4::SetUpTestCase()
49 {
50 }
51 
TearDownTestCase()52 void SceneSessionTest4::TearDownTestCase()
53 {
54 }
55 
SetUp()56 void SceneSessionTest4::SetUp()
57 {
58     sceneSession = new (std::nothrow) SceneSession(info, nullptr);
59     property = new (std::nothrow) WindowSessionProperty();
60     action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
61 }
62 
TearDown()63 void SceneSessionTest4::TearDown()
64 {
65 }
66 
67 namespace {
68 /**
69  * @tc.name: HandleActionUpdateFlags
70  * @tc.desc: normal function
71  * @tc.type: FUNC
72  */
HWTEST_F(SceneSessionTest4, HandleActionUpdateFlags, Function | SmallTest | Level2)73 HWTEST_F(SceneSessionTest4, HandleActionUpdateFlags, Function | SmallTest | Level2)
74 {
75     SessionInfo info;
76     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
77     ASSERT_NE(nullptr, sceneSession);
78     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
79     ASSERT_NE(nullptr, property);
80     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
81     WMError ret = sceneSession->HandleActionUpdateStatusProps(property, action);
82     ASSERT_EQ(WMError::WM_OK, ret);
83     ret = sceneSession->HandleActionUpdateNavigationProps(property, action);
84     ASSERT_EQ(WMError::WM_OK, ret);
85     ret = sceneSession->HandleActionUpdateNavigationIndicatorProps(property, action);
86     ASSERT_EQ(WMError::WM_OK, ret);
87     ret = sceneSession->HandleActionUpdateFlags(property, action);
88     ASSERT_EQ(WMError::WM_OK, ret);
89 }
90 
91 /**
92  * @tc.name: HandleActionUpdateTouchHotArea
93  * @tc.desc: normal function
94  * @tc.type: FUNC
95  */
HWTEST_F(SceneSessionTest4, HandleActionUpdateTouchHotArea, Function | SmallTest | Level2)96 HWTEST_F(SceneSessionTest4, HandleActionUpdateTouchHotArea, Function | SmallTest | Level2)
97 {
98     SessionInfo info;
99     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
100     ASSERT_NE(nullptr, sceneSession);
101     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
102     ASSERT_NE(nullptr, property);
103     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
104     sceneSession->HandleActionUpdateTouchHotArea(property, action);
105     OHOS::Rosen::Session session(info);
106     session.property_ = new WindowSessionProperty();
107     sceneSession->HandleActionUpdateTouchHotArea(property, action);
108 
109     sceneSession->SetSessionProperty(nullptr);
110     sceneSession->HandleActionUpdateTouchHotArea(property, action);
111 }
112 
113 /**
114  * @tc.name: HandleActionUpdateDecorEnable
115  * @tc.desc: normal function
116  * @tc.type: FUNC
117  */
HWTEST_F(SceneSessionTest4, HandleActionUpdateDecorEnable, Function | SmallTest | Level2)118 HWTEST_F(SceneSessionTest4, HandleActionUpdateDecorEnable, Function | SmallTest | Level2)
119 {
120     SessionInfo info;
121     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
122     ASSERT_NE(nullptr, sceneSession);
123     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
124 
125     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
126     ASSERT_NE(nullptr, property);
127     OHOS::Rosen::Session session(info);
128     session.property_ = nullptr;
129     sceneSession->HandleActionUpdateDecorEnable(property, action);
130     session.property_ = new WindowSessionProperty();
131     sceneSession->HandleActionUpdateDecorEnable(property, action);
132 
133     OHOS::Rosen::WindowSessionProperty windowSessionProperty;
134     auto ret = sceneSession->HandleActionUpdateDecorEnable(property, action);
135     ASSERT_EQ(WMError::WM_OK, ret);
136 }
137 
138 /**
139  * @tc.name: HandleActionUpdateWindowLimits
140  * @tc.desc: normal function
141  * @tc.type: FUNC
142  */
HWTEST_F(SceneSessionTest4, HandleActionUpdateWindowLimits, Function | SmallTest | Level2)143 HWTEST_F(SceneSessionTest4, HandleActionUpdateWindowLimits, Function | SmallTest | Level2)
144 {
145     SessionInfo info;
146     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
147     ASSERT_NE(nullptr, sceneSession);
148     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
149     ASSERT_NE(nullptr, property);
150 
151     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
152     OHOS::Rosen::Session session(info);
153     session.property_ = nullptr;
154     sceneSession->HandleActionUpdateWindowLimits(property, action);
155     session.property_ = new WindowSessionProperty();
156     sceneSession->HandleActionUpdateWindowLimits(property, action);
157 }
158 
159 /**
160  * @tc.name: HandleActionUpdateDragenabled
161  * @tc.desc: normal function
162  * @tc.type: FUNC
163  */
HWTEST_F(SceneSessionTest4, HandleActionUpdateDragenabled, Function | SmallTest | Level2)164 HWTEST_F(SceneSessionTest4, HandleActionUpdateDragenabled, Function | SmallTest | Level2)
165 {
166     SessionInfo info;
167     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
168     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
169     OHOS::Rosen::Session session(info);
170     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
171     session.property_ = property;
172 
173     WMError res = sceneSession->HandleActionUpdateDragenabled(property, action);
174     ASSERT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, res);
175 
176     session.property_->SetSystemCalling(true);
177     res = sceneSession->HandleActionUpdateDragenabled(property, action);
178     ASSERT_EQ(WMError::WM_OK, res);
179 }
180 
181 /**
182  * @tc.name: HandleActionUpdateRaiseenabled
183  * @tc.desc: normal function
184  * @tc.type: FUNC
185  */
HWTEST_F(SceneSessionTest4, HandleActionUpdateRaiseenabled, Function | SmallTest | Level2)186 HWTEST_F(SceneSessionTest4, HandleActionUpdateRaiseenabled, Function | SmallTest | Level2)
187 {
188     ASSERT_NE(nullptr, sceneSession);
189     ASSERT_NE(nullptr, property);
190     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ANIMATION_FLAG;
191     sceneSession->HandleActionUpdateRaiseenabled(property, action);
192 
193     OHOS::Rosen::WindowSessionProperty windowSessionProperty;
194     windowSessionProperty.isSystemCalling_ = {true};
195     sceneSession->HandleActionUpdateRaiseenabled(property, action);
196 
197     windowSessionProperty.isSystemCalling_ = {true};
198     OHOS::Rosen::Session session(info);
199     session.property_ = new WindowSessionProperty();
200     sceneSession->HandleActionUpdateRaiseenabled(property, action);
201 
202     sceneSession->HandleActionUpdateHideNonSystemFloatingWindows(property, action);
203 }
204 
205 /**
206  * @tc.name: HandleActionUpdateTextfieldAvoidInfo
207  * @tc.desc: normal function
208  * @tc.type: FUNC
209  */
HWTEST_F(SceneSessionTest4, HandleActionUpdateTextfieldAvoidInfo, Function | SmallTest | Level2)210 HWTEST_F(SceneSessionTest4, HandleActionUpdateTextfieldAvoidInfo, Function | SmallTest | Level2)
211 {
212     ASSERT_NE(nullptr, sceneSession);
213     ASSERT_NE(nullptr, property);
214     sceneSession->HandleActionUpdateTextfieldAvoidInfo(property, action);
215     sceneSession->HandleActionUpdateWindowMask(property, action);
216 
217     OHOS::Rosen::Session session(info);
218     session.property_ = new WindowSessionProperty();
219     sceneSession->HandleActionUpdateTextfieldAvoidInfo(property, action);
220     sceneSession->HandleActionUpdateWindowMask(property, action);
221     sceneSession->HandleActionUpdateTopmost(property, action);
222 
223     SessionInfo info;
224     sptr<SceneSession> sceneSession1 = new (std::nothrow) SceneSession(info, nullptr);
225     ASSERT_NE(nullptr, sceneSession1);
226     sceneSession1->SetSessionProperty(nullptr);
227     sceneSession1->HandleActionUpdateTextfieldAvoidInfo(property, action);
228     sceneSession1->HandleActionUpdateWindowMask(property, action);
229 }
230 
231 /**
232  * @tc.name: SetWindowFlags
233  * @tc.desc: normal function
234  * @tc.type: FUNC
235  */
HWTEST_F(SceneSessionTest4, SetWindowFlags, Function | SmallTest | Level2)236 HWTEST_F(SceneSessionTest4, SetWindowFlags, Function | SmallTest | Level2)
237 {
238     ASSERT_NE(nullptr, sceneSession);
239     ASSERT_NE(nullptr, property);
240     sceneSession->SetWindowFlags(property);
241 
242     OHOS::Rosen::Session session(info);
243     session.property_ = new WindowSessionProperty();
244     sceneSession->SetWindowFlags(property);
245     sceneSession->NotifySessionChangeByActionNotifyManager(property, action);
246 
247     session.property_ = nullptr;
248     sceneSession->SetWindowFlags(property);
249     sceneSession->sessionChangeByActionNotifyManagerFunc_ = [](
250         const sptr<SceneSession>& sceneSession,
251         const sptr<WindowSessionProperty>& property, WSPropertyChangeAction action
252     ){};
253     sceneSession->NotifySessionChangeByActionNotifyManager(property, action);
254 }
255 
256 /**
257  * @tc.name: SetSkipDraw
258  * @tc.desc: SetSkipDraw function
259  * @tc.type: FUNC
260  */
HWTEST_F(SceneSessionTest4, SetSkipDraw, Function | SmallTest | Level2)261 HWTEST_F(SceneSessionTest4, SetSkipDraw, Function | SmallTest | Level2)
262 {
263     SessionInfo info;
264     info.abilityName_ = "SetSkipDraw";
265     info.bundleName_ = "SetSkipDraw";
266     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
267     EXPECT_NE(nullptr, session);
268     struct RSSurfaceNodeConfig config;
269     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
270     session->surfaceNode_ = surfaceNode;
271     session->SetLeashWinSurfaceNode(nullptr);
272     session->SetSkipDraw(true);
273     session->SetLeashWinSurfaceNode(surfaceNode);
274     EXPECT_EQ(surfaceNode, session->GetLeashWinSurfaceNode());
275     session->SetSkipDraw(true);
276 }
277 
278 /**
279  * @tc.name: SetScale
280  * @tc.desc: SetScale function
281  * @tc.type: FUNC
282  */
HWTEST_F(SceneSessionTest4, SetScale, Function | SmallTest | Level2)283 HWTEST_F(SceneSessionTest4, SetScale, Function | SmallTest | Level2)
284 {
285     SessionInfo info;
286     info.abilityName_ = "SetScale";
287     info.bundleName_ = "SetScale";
288     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
289     EXPECT_NE(nullptr, session);
290     session->Session::SetScale(1.0f, 2.0f, 3.0f, 4.0f);
291     session->sessionStage_ = nullptr;
292     session->SetScale(5.0f, 2.0f, 3.0f, 4.0f);
293     sptr<SceneSession::SpecificSessionCallback> specificCallback =
294         sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
295     NotifyWindowInfoUpdateCallback func = [](int32_t persistentId, WindowUpdateType type) {
296         return;
297     };
298     specificCallback->onWindowInfoUpdate_ = func;
299     session->specificCallback_ = specificCallback;
300     session->SetScale(5.0f, 5.0f, 3.0f, 4.0f);
301     session->SetScale(5.0f, 5.0f, 5.0f, 4.0f);
302     session->SetScale(5.0f, 5.0f, 5.0f, 5.0f);
303     session->SetScale(5.0f, 5.0f, 5.0f, 5.0f);
304     EXPECT_EQ(5.0f, session->GetScaleX());
305     EXPECT_EQ(5.0f, session->GetScaleY());
306     EXPECT_EQ(5.0f, session->GetPivotX());
307     EXPECT_EQ(5.0f, session->GetPivotY());
308 
309     session->sessionStage_ = new SessionStageMocker();
310     EXPECT_NE(nullptr, session->sessionStage_);
311     session->SetScale(5.0f, 5.0f, 5.0f, 5.0f);
312     EXPECT_EQ(5.0f, session->GetPivotY());
313 }
314 
315 /**
316  * @tc.name: RequestSessionBack
317  * @tc.desc: RequestSessionBack function
318  * @tc.type: FUNC
319  */
HWTEST_F(SceneSessionTest4, RequestSessionBack, Function | SmallTest | Level2)320 HWTEST_F(SceneSessionTest4, RequestSessionBack, Function | SmallTest | Level2)
321 {
322     SessionInfo info;
323     info.abilityName_ = "RequestSessionBack";
324     info.bundleName_ = "RequestSessionBack";
325     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
326     EXPECT_NE(nullptr, session);
327     NotifyBackPressedFunc func = [](const bool needMoveToBackground) {
328         return;
329     };
330     session->backPressedFunc_ = func;
331     EXPECT_EQ(WSError::WS_OK, session->RequestSessionBack(true));
332 }
333 
334 /**
335  * @tc.name: SetSurfaceBounds
336  * @tc.desc: SetSurfaceBounds function
337  * @tc.type: FUNC
338  */
HWTEST_F(SceneSessionTest4, SetSurfaceBounds, Function | SmallTest | Level2)339 HWTEST_F(SceneSessionTest4, SetSurfaceBounds, Function | SmallTest | Level2)
340 {
341     SessionInfo info;
342     info.abilityName_ = "SetSurfaceBounds";
343     info.bundleName_ = "SetSurfaceBounds";
344     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
345     EXPECT_NE(nullptr, session);
346     WSRect rect;
347     struct RSSurfaceNodeConfig config;
348     std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
349     session->surfaceNode_ = surfaceNode;
350     session->SetSurfaceBounds(rect);
351     session->SetLeashWinSurfaceNode(surfaceNode);
352     session->SetSurfaceBounds(rect);
353     EXPECT_NE(nullptr, session->GetLeashWinSurfaceNode());
354 }
355 
356 /**
357  * @tc.name: SetFloatingScale
358  * @tc.desc: SetFloatingScale function
359  * @tc.type: FUNC
360  */
HWTEST_F(SceneSessionTest4, SetFloatingScale, Function | SmallTest | Level2)361 HWTEST_F(SceneSessionTest4, SetFloatingScale, Function | SmallTest | Level2)
362 {
363     SessionInfo info;
364     info.abilityName_ = "SetFloatingScale";
365     info.bundleName_ = "SetFloatingScale";
366     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
367     EXPECT_NE(nullptr, session);
368     session->floatingScale_ = 3.14f;
369     session->SetFloatingScale(2.176f);
370     session->SetFloatingScale(3.14f);
371     EXPECT_EQ(nullptr, session->specificCallback_);
372 }
373 
374 /**
375  * @tc.name: GetSessionSnapshotFilePath
376  * @tc.desc: GetSessionSnapshotFilePath function
377  * @tc.type: FUNC
378  */
HWTEST_F(SceneSessionTest4, GetSessionSnapshotFilePath, Function | SmallTest | Level2)379 HWTEST_F(SceneSessionTest4, GetSessionSnapshotFilePath, Function | SmallTest | Level2)
380 {
381     SessionInfo info;
382     info.abilityName_ = "GetSessionSnapshotFilePath";
383     info.bundleName_ = "GetSessionSnapshotFilePath";
384     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
385     session->Session::SetSessionState(SessionState::STATE_DISCONNECT);
386     session->scenePersistence_ = sptr<ScenePersistence>::MakeSptr("GetSessionSnapshotFilePath", 1);
387     EXPECT_EQ("GetSessionSnapshotFilePath_1.astc", session->GetSessionSnapshotFilePath());
388 
389     session->SetSessionState(SessionState::STATE_BACKGROUND);
390     EXPECT_EQ("GetSessionSnapshotFilePath_1.astc", session->GetSessionSnapshotFilePath());
391 }
392 
393 /**
394  * @tc.name: SetRequestedOrientation
395  * @tc.desc: SetRequestedOrientation function
396  * @tc.type: FUNC
397  */
HWTEST_F(SceneSessionTest4, SetRequestedOrientation, Function | SmallTest | Level2)398 HWTEST_F(SceneSessionTest4, SetRequestedOrientation, Function | SmallTest | Level2)
399 {
400     SessionInfo info;
401     info.abilityName_ = "SetRequestedOrientation";
402     info.bundleName_ = "SetRequestedOrientation";
403     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
404     Orientation orientation { Orientation::BEGIN };
405     session->sessionChangeCallback_ = nullptr;
406     session->SetRequestedOrientation(orientation);
407     session->sessionChangeCallback_ = sptr<SceneSession::SessionChangeCallback>::MakeSptr();
408     session->sessionChangeCallback_->OnRequestedOrientationChange_ = nullptr;
409     session->SetRequestedOrientation(orientation);
410     NotifyReqOrientationChangeFunc func = [](uint32_t orientation) {
411         return;
412     };
413     session->sessionChangeCallback_->OnRequestedOrientationChange_ = func;
414     session->SetRequestedOrientation(orientation);
415     EXPECT_NE(nullptr, session->sessionChangeCallback_->OnRequestedOrientationChange_);
416 }
417 
418 /**
419  * @tc.name: UpdateSessionPropertyByAction
420  * @tc.desc: UpdateSessionPropertyByAction function
421  * @tc.type: FUNC
422  */
HWTEST_F(SceneSessionTest4, UpdateSessionPropertyByAction, Function | SmallTest | Level2)423 HWTEST_F(SceneSessionTest4, UpdateSessionPropertyByAction, Function | SmallTest | Level2)
424 {
425     SessionInfo info;
426     info.abilityName_ = "UpdateSessionPropertyByAction";
427     info.bundleName_ = "UpdateSessionPropertyByAction";
428     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
429     ASSERT_NE(nullptr, sceneSession);
430     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
431     ASSERT_NE(nullptr, property);
432     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE;
433     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, sceneSession->UpdateSessionPropertyByAction(nullptr, action));
434 
435     sceneSession->SetSessionProperty(nullptr);
436     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, sceneSession->UpdateSessionPropertyByAction(property, action));
437 
438     sceneSession->SetSessionProperty(property);
439     EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, sceneSession->UpdateSessionPropertyByAction(property, action));
440 
441     action = WSPropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON;
442     EXPECT_EQ(WMError::WM_OK, sceneSession->UpdateSessionPropertyByAction(property, action));
443 }
444 
445 /**
446  * @tc.name: ProcessUpdatePropertyByAction1
447  * @tc.desc: ProcessUpdatePropertyByAction1 function
448  * @tc.type: FUNC
449  */
HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction1, Function | SmallTest | Level2)450 HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction1, Function | SmallTest | Level2)
451 {
452     SessionInfo info;
453     info.abilityName_ = "ProcessUpdatePropertyByAction1";
454     info.bundleName_ = "ProcessUpdatePropertyByAction1";
455     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
456     ASSERT_NE(nullptr, sceneSession);
457     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
458     ASSERT_NE(nullptr, property);
459 
460     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
461         WSPropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON));
462 
463     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
464         WSPropertyChangeAction::ACTION_UPDATE_KEEP_SCREEN_ON));
465 
466     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
467         WSPropertyChangeAction::ACTION_UPDATE_FOCUSABLE));
468 
469     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
470         WSPropertyChangeAction::ACTION_UPDATE_TOUCHABLE));
471 
472     sceneSession->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
473     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
474         WSPropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS));
475 
476     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
477     sceneSession->state_ = SessionState::STATE_END;
478     EXPECT_EQ(WMError::WM_ERROR_INVALID_SESSION, sceneSession->ProcessUpdatePropertyByAction(property,
479         WSPropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS));
480 
481     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
482     sceneSession->state_ = SessionState::STATE_ACTIVE;
483     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
484         WSPropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS));
485 
486     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
487         WSPropertyChangeAction::ACTION_UPDATE_ORIENTATION));
488 
489     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
490         WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE));
491 
492     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
493         WSPropertyChangeAction::ACTION_UPDATE_SYSTEM_PRIVACY_MODE));
494 
495     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
496         WSPropertyChangeAction::ACTION_UPDATE_SNAPSHOT_SKIP));
497 }
498 
499 /**
500  * @tc.name: ProcessUpdatePropertyByAction2
501  * @tc.desc: ProcessUpdatePropertyByAction2 function
502  * @tc.type: FUNC
503  */
HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction2, Function | SmallTest | Level2)504 HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction2, Function | SmallTest | Level2)
505 {
506     SessionInfo info;
507     info.abilityName_ = "ProcessUpdatePropertyByAction2";
508     info.bundleName_ = "ProcessUpdatePropertyByAction2";
509     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
510     ASSERT_NE(nullptr, sceneSession);
511     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
512     ASSERT_NE(nullptr, property);
513 
514     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
515         WSPropertyChangeAction::ACTION_UPDATE_MAXIMIZE_STATE));
516 
517     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
518         WSPropertyChangeAction::ACTION_UPDATE_OTHER_PROPS));
519 
520     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
521         WSPropertyChangeAction::ACTION_UPDATE_STATUS_PROPS));
522 
523     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
524         WSPropertyChangeAction::ACTION_UPDATE_NAVIGATION_PROPS));
525 
526     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
527         WSPropertyChangeAction::ACTION_UPDATE_NAVIGATION_INDICATOR_PROPS));
528 
529     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
530         WSPropertyChangeAction::ACTION_UPDATE_FLAGS));
531 
532     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
533         WSPropertyChangeAction::ACTION_UPDATE_MODE));
534 
535     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
536         WSPropertyChangeAction::ACTION_UPDATE_ANIMATION_FLAG));
537 
538     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
539         WSPropertyChangeAction::ACTION_UPDATE_TOUCH_HOT_AREA));
540 
541     property->SetSystemCalling(false);
542     EXPECT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, sceneSession->ProcessUpdatePropertyByAction(property,
543         WSPropertyChangeAction::ACTION_UPDATE_DECOR_ENABLE));
544 
545     property->SetSystemCalling(true);
546     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
547         WSPropertyChangeAction::ACTION_UPDATE_DECOR_ENABLE));
548 }
549 
550 /**
551  * @tc.name: ProcessUpdatePropertyByAction3
552  * @tc.desc: ProcessUpdatePropertyByAction3 function
553  * @tc.type: FUNC
554  */
HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction3, Function | SmallTest | Level2)555 HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction3, Function | SmallTest | Level2)
556 {
557     SessionInfo info;
558     info.abilityName_ = "ProcessUpdatePropertyByAction3";
559     info.bundleName_ = "ProcessUpdatePropertyByAction3";
560     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
561     ASSERT_NE(nullptr, sceneSession);
562     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
563     ASSERT_NE(nullptr, property);
564 
565     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
566         WSPropertyChangeAction::ACTION_UPDATE_WINDOW_LIMITS));
567 
568     property->SetSystemCalling(false);
569     EXPECT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, sceneSession->ProcessUpdatePropertyByAction(property,
570         WSPropertyChangeAction::ACTION_UPDATE_DRAGENABLED));
571 
572     property->SetSystemCalling(true);
573     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
574         WSPropertyChangeAction::ACTION_UPDATE_DRAGENABLED));
575 
576     sceneSession->property_ = property;
577     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
578         WSPropertyChangeAction::ACTION_UPDATE_DRAGENABLED));
579 
580     property->SetSystemCalling(false);
581     EXPECT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, sceneSession->ProcessUpdatePropertyByAction(property,
582         WSPropertyChangeAction::ACTION_UPDATE_RAISEENABLED));
583 
584     property->SetSystemCalling(true);
585     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
586         WSPropertyChangeAction::ACTION_UPDATE_RAISEENABLED));
587 
588     sceneSession->property_ = property;
589     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
590         WSPropertyChangeAction::ACTION_UPDATE_RAISEENABLED));
591 
592     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
593         WSPropertyChangeAction::ACTION_UPDATE_HIDE_NON_SYSTEM_FLOATING_WINDOWS));
594 
595     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
596         WSPropertyChangeAction::ACTION_UPDATE_TEXTFIELD_AVOID_INFO));
597 
598     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
599         WSPropertyChangeAction::ACTION_UPDATE_WINDOW_MASK));
600 
601     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
602         WSPropertyChangeAction::ACTION_UPDATE_TOPMOST));
603 
604     property->SetSystemCalling(false);
605     EXPECT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, sceneSession->ProcessUpdatePropertyByAction(property,
606         WSPropertyChangeAction::ACTION_UPDATE_MODE_SUPPORT_INFO));
607 
608     property->SetSystemCalling(true);
609     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
610         WSPropertyChangeAction::ACTION_UPDATE_MODE_SUPPORT_INFO));
611 
612     EXPECT_EQ(WMError::WM_DO_NOTHING, sceneSession->ProcessUpdatePropertyByAction(property,
613         WSPropertyChangeAction::ACTION_UPDATE_RECT));
614 }
615 
616 /**
617  * @tc.name: ProcessUpdatePropertyByAction4
618  * @tc.desc: ProcessUpdatePropertyByAction4 function
619  * @tc.type: FUNC
620  */
HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction4, Function | SmallTest | Level2)621 HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction4, Function | SmallTest | Level2)
622 {
623     SessionInfo info;
624     info.abilityName_ = "ProcessUpdatePropertyByAction4";
625     info.bundleName_ = "ProcessUpdatePropertyByAction4";
626     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
627     ASSERT_NE(nullptr, sceneSession);
628     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
629     ASSERT_NE(nullptr, property);
630     property->SetSystemCalling(true);
631     sceneSession->property_ = property;
632     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
633         WSPropertyChangeAction::ACTION_UPDATE_WINDOW_LIMITS));
634 
635     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
636         WSPropertyChangeAction::ACTION_UPDATE_DECOR_ENABLE));
637 
638     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
639         WSPropertyChangeAction::ACTION_UPDATE_HIDE_NON_SYSTEM_FLOATING_WINDOWS));
640 
641     sceneSession->property_ = nullptr;
642     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
643         WSPropertyChangeAction::ACTION_UPDATE_DRAGENABLED));
644 
645     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
646         WSPropertyChangeAction::ACTION_UPDATE_RAISEENABLED));
647 
648     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
649         WSPropertyChangeAction::ACTION_UPDATE_WINDOW_LIMITS));
650 
651     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
652         WSPropertyChangeAction::ACTION_UPDATE_DECOR_ENABLE));
653 
654     EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property,
655         WSPropertyChangeAction::ACTION_UPDATE_HIDE_NON_SYSTEM_FLOATING_WINDOWS));
656 }
657 
658 /**
659  * @tc.name: HandleSpecificSystemBarProperty
660  * @tc.desc: HandleSpecificSystemBarProperty
661  * @tc.type: FUNC
662  */
HWTEST_F(SceneSessionTest4, HandleSpecificSystemBarProperty, Function | SmallTest | Level2)663 HWTEST_F(SceneSessionTest4, HandleSpecificSystemBarProperty, Function | SmallTest | Level2)
664 {
665     SessionInfo info;
666     info.abilityName_ = "HandleSpecificSystemBarProperty";
667     info.bundleName_ = "HandleSpecificSystemBarProperty";
668     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
669     ASSERT_NE(nullptr, sceneSession);
670     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
671     ASSERT_NE(nullptr, property);
672     WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
673     sceneSession->HandleSpecificSystemBarProperty(type, property);
674 
675     sceneSession->isDisplayStatusBarTemporarily_.store(true);
676     sceneSession->HandleSpecificSystemBarProperty(type, property);
677 
678     sceneSession->specificCallback_ = nullptr;
679     sceneSession->HandleSpecificSystemBarProperty(type, property);
680 
681     sptr<SceneSession::SpecificSessionCallback> specificCallback =
682         new (std::nothrow) SceneSession::SpecificSessionCallback();
683     ASSERT_NE(nullptr, specificCallback);
684     sceneSession->specificCallback_ = specificCallback;
685     sceneSession->HandleSpecificSystemBarProperty(type, property);
686 
687     sceneSession->specificCallback_->onUpdateAvoidArea_ = nullptr;
688     sceneSession->HandleSpecificSystemBarProperty(type, property);
689 
690     UpdateAvoidAreaCallback onUpdateAvoidArea;
691     sceneSession->specificCallback_->onUpdateAvoidArea_ = onUpdateAvoidArea;
692     sceneSession->HandleSpecificSystemBarProperty(type, property);
693 }
694 
695 /**
696  * @tc.name: SetWindowFlags1
697  * @tc.desc: SetWindowFlags1
698  * @tc.type: FUNC
699  */
HWTEST_F(SceneSessionTest4, SetWindowFlags1, Function | SmallTest | Level2)700 HWTEST_F(SceneSessionTest4, SetWindowFlags1, Function | SmallTest | Level2)
701 {
702     SessionInfo info;
703     info.abilityName_ = "SetWindowFlags1";
704     info.bundleName_ = "SetWindowFlags1";
705     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
706     ASSERT_NE(nullptr, sceneSession);
707     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
708     ASSERT_NE(nullptr, property);
709     sptr<WindowSessionProperty> sessionProperty = new (std::nothrow) WindowSessionProperty();
710     ASSERT_NE(nullptr, sessionProperty);
711     sceneSession->SetWindowFlags(property);
712     sceneSession->property_ = sessionProperty;
713     property->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_PARENT_LIMIT));
714     sceneSession->property_->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
715     sceneSession->SetWindowFlags(property);
716     property->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE));
717     sceneSession->property_->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK));
718     sceneSession->SetWindowFlags(property);
719 }
720 
721 /**
722  * @tc.name: SetGestureBackEnabled
723  * @tc.desc: SetGestureBackEnabled
724  * @tc.type: FUNC
725  */
HWTEST_F(SceneSessionTest4, SetGestureBackEnabled, Function | SmallTest | Level2)726 HWTEST_F(SceneSessionTest4, SetGestureBackEnabled, Function | SmallTest | Level2)
727 {
728     SessionInfo info;
729     info.abilityName_ = "SetGestureBackEnabled";
730     info.bundleName_ = "SetGestureBackEnabled";
731     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
732     ASSERT_NE(nullptr, sceneSession);
733     sceneSession->isEnableGestureBack_ = false;
734     EXPECT_EQ(WMError::WM_OK, sceneSession->SetGestureBackEnabled(false));
735     sceneSession->specificCallback_ = new SceneSession::SpecificSessionCallback();
736     EXPECT_NE(nullptr, sceneSession->specificCallback_);
737     auto func = [sceneSession](int32_t persistentId) {
738         return;
739     };
740     sceneSession->specificCallback_->onUpdateGestureBackEnabled_ = func;
741     EXPECT_EQ(WMError::WM_OK, sceneSession->SetGestureBackEnabled(true));
742     EXPECT_EQ(true, sceneSession->GetGestureBackEnabled());
743 }
744 
745 /**
746  * @tc.name: GetCustomDecorHeight02
747  * @tc.desc: GetCustomDecorHeight
748  * @tc.type: FUNC
749 */
HWTEST_F(SceneSessionTest4, GetCustomDecorHeight02, Function | SmallTest | Level3)750 HWTEST_F(SceneSessionTest4, GetCustomDecorHeight02, Function | SmallTest | Level3)
751 {
752     SessionInfo info;
753     info.abilityName_ = "GetCustomDecorHeight";
754     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
755     sceneSession->SetCustomDecorHeight(50);
756     sceneSession->SetCustomDecorHeight(20);
757     ASSERT_EQ(50, sceneSession->customDecorHeight_);
758 
759     sptr<SceneSession> sceneSession2 = sptr<SceneSession>::MakeSptr(info, nullptr);
760     sceneSession2->SetCustomDecorHeight(50);
761     sceneSession2->SetCustomDecorHeight(150);
762     ASSERT_EQ(50, sceneSession2->customDecorHeight_);
763 }
764 
765 /**
766  * @tc.name: SetDefaultDisplayIdIfNeed03
767  * @tc.desc: SetDefaultDisplayIdIfNeed
768  * @tc.type: FUNC
769  */
HWTEST_F(SceneSessionTest4, SetDefaultDisplayIdIfNeed03, Function | SmallTest | Level2)770 HWTEST_F(SceneSessionTest4, SetDefaultDisplayIdIfNeed03, Function | SmallTest | Level2)
771 {
772     SessionInfo info;
773     info.abilityName_ = "SetDefaultDisplayIdIfNeed03";
774     info.bundleName_ = "SetDefaultDisplayIdIfNeed03";
775     info.screenId_ = 20;
776     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
777     sceneSession->SetSessionProperty(nullptr);
778     sceneSession->SetDefaultDisplayIdIfNeed();
779     ASSERT_EQ(20, sceneSession->GetSessionInfo().screenId_);
780 }
781 
782 /**
783  * @tc.name: NotifyServerToUpdateRect01
784  * @tc.desc: NotifyServerToUpdateRect
785  * @tc.type: FUNC
786  */
HWTEST_F(SceneSessionTest4, NotifyServerToUpdateRect01, Function | SmallTest | Level2)787 HWTEST_F(SceneSessionTest4, NotifyServerToUpdateRect01, Function | SmallTest | Level2)
788 {
789     SessionInfo info;
790     info.abilityName_ = "NotifyServerToUpdateRect";
791     info.bundleName_ = "NotifyServerToUpdateRect";
792     info.screenId_ = 20;
793     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
794     sceneSession->SetSessionProperty(nullptr);
795     SessionUIParam uiParam;
796     SizeChangeReason reason = SizeChangeReason::UNDEFINED;;
797     sceneSession->SetForegroundInteractiveStatus(false);
798     sceneSession->NotifyServerToUpdateRect(uiParam, reason);
799     ASSERT_EQ(false, sceneSession->NotifyServerToUpdateRect(uiParam, reason));
800 
801     sceneSession->SetForegroundInteractiveStatus(true);
802     ASSERT_EQ(false, sceneSession->NotifyServerToUpdateRect(uiParam, reason));
803 
804     uiParam.needSync_ = false;
805     ASSERT_EQ(false, sceneSession->NotifyServerToUpdateRect(uiParam, reason));
806 
807     uiParam.needSync_ = true;
808     uiParam.rect_ = {0, 0, 1, 1};
809 
810     sceneSession->winRect_ = {0, 0, 1, 1};
811     ASSERT_EQ(false, sceneSession->NotifyServerToUpdateRect(uiParam, reason));
812 
813     sceneSession->winRect_ = {1, 1, 1, 1};
814     ASSERT_EQ(true, sceneSession->NotifyServerToUpdateRect(uiParam, reason));
815 
816     uiParam.rect_ = {0, 0, 1, 0};
817     ASSERT_EQ(false, sceneSession->NotifyServerToUpdateRect(uiParam, reason));
818 }
819 
820 /**
821  * @tc.name: UpdateRectInner
822  * @tc.desc: UpdateRectInner
823  * @tc.type: FUNC
824  */
HWTEST_F(SceneSessionTest4, UpdateRectInner01, Function | SmallTest | Level2)825 HWTEST_F(SceneSessionTest4, UpdateRectInner01, Function | SmallTest | Level2)
826 {
827     SessionInfo info;
828     info.abilityName_ = "UpdateRectInner01";
829     info.bundleName_ = "UpdateRectInner01";
830     info.screenId_ = 20;
831     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
832     sceneSession->SetSessionProperty(nullptr);
833     SessionUIParam uiParam;
834     SizeChangeReason reason = SizeChangeReason::UNDEFINED;
835     sceneSession->SetForegroundInteractiveStatus(true);
836 
837     uiParam.needSync_ = true;
838     uiParam.rect_ = {0, 0, 1, 1};
839 
840     sceneSession->winRect_ = {1, 1, 1, 1};
841     sceneSession->isVisible_ = true;
842     ASSERT_EQ(false, sceneSession->UpdateRectInner(uiParam, reason));
843 }
844 
845 /**
846  * @tc.name: UpdateVisibilityInner
847  * @tc.desc: UpdateVisibilityInner
848  * @tc.type: FUNC
849  */
HWTEST_F(SceneSessionTest4, UpdateVisibilityInner01, Function | SmallTest | Level2)850 HWTEST_F(SceneSessionTest4, UpdateVisibilityInner01, Function | SmallTest | Level2)
851 {
852     SessionInfo info;
853     info.abilityName_ = "UpdateVisibilityInner01";
854     info.bundleName_ = "UpdateVisibilityInner01";
855     info.screenId_ = 20;
856     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
857     sceneSession->isVisible_ = false;
858     ASSERT_EQ(false, sceneSession->UpdateVisibilityInner(false));
859 
860     sceneSession->SetSessionProperty(nullptr);
861     VisibilityChangedDetectFunc func = [sceneSession](const int32_t pid, const bool isVisible,
862         const bool newIsVisible) {
863             return;
864     };
865     sceneSession->SetVisibilityChangedDetectFunc(func);
866 
867     UpdatePrivateStateAndNotifyFunc func1 = [sceneSession](int32_t persistentId) {
868         return;
869     };
870     ASSERT_EQ(true, sceneSession->UpdateVisibilityInner(true));
871 }
872 
873 /**
874  * @tc.name: UnregisterSessionChangeListeners
875  * @tc.desc: UnregisterSessionChangeListeners
876  * @tc.type: FUNC
877  */
HWTEST_F(SceneSessionTest4, UnregisterSessionChangeListeners01, Function | SmallTest | Level2)878 HWTEST_F(SceneSessionTest4, UnregisterSessionChangeListeners01, Function | SmallTest | Level2)
879 {
880     SessionInfo info;
881     info.abilityName_ = "UnregisterSessionChangeListeners01";
882     info.bundleName_ = "UnregisterSessionChangeListeners01";
883     info.screenId_ = 20;
884     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
885     sceneSession->UnregisterSessionChangeListeners();
886 
887     sceneSession->sessionChangeCallback_ = new (std::nothrow) MainSession::SessionChangeCallback();
888     ASSERT_NE(sceneSession->sessionChangeCallback_, nullptr);
889     sceneSession->UnregisterSessionChangeListeners();
890     NotifyPendingSessionToBackgroundForDelegatorFunc func =[sceneSession](const SessionInfo& info,
891         bool shouldBackToCaller) { return; };
892     sceneSession->pendingSessionToBackgroundForDelegatorFunc_ = func;
893     ASSERT_EQ(WSError::WS_OK, sceneSession->PendingSessionToBackgroundForDelegator(true));
894 }
895 
896 /**
897  * @tc.name: IsPcOrPadEnableActivation01
898  * @tc.desc: IsPcOrPadEnableActivation
899  * @tc.type: FUNC
900  */
HWTEST_F(SceneSessionTest4, IsPcOrPadEnableActivation01, Function | SmallTest | Level2)901 HWTEST_F(SceneSessionTest4, IsPcOrPadEnableActivation01, Function | SmallTest | Level2)
902 {
903     SessionInfo info;
904     info.abilityName_ = "IsPcOrPadEnableActivation01";
905     info.bundleName_ = "IsPcOrPadEnableActivation01";
906     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
907 
908     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>();
909     sceneSession->SetSessionProperty(property);
910     ASSERT_EQ(false, sceneSession->IsPcOrPadEnableActivation());
911 }
912 
913 /**
914  * @tc.name: IsPcOrPadEnableActivation02
915  * @tc.desc: IsPcOrPadEnableActivation
916  * @tc.type: FUNC
917  */
HWTEST_F(SceneSessionTest4, IsPcOrPadEnableActivation02, Function | SmallTest | Level2)918 HWTEST_F(SceneSessionTest4, IsPcOrPadEnableActivation02, Function | SmallTest | Level2)
919 {
920     SessionInfo info;
921     info.abilityName_ = "IsPcOrPadEnableActivation02";
922     info.bundleName_ = "IsPcOrPadEnableActivation02";
923     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
924     sceneSession->SetSessionProperty(nullptr);
925     ASSERT_EQ(false, sceneSession->IsPcOrPadEnableActivation());
926 }
927 
928 /**
929  * @tc.name: SetSystemWindowEnableDrag01
930  * @tc.desc: SetSystemWindowEnableDrag function01
931  * @tc.type: FUNC
932  */
HWTEST_F(SceneSessionTest4, SetSystemWindowEnableDrag01, Function | SmallTest | Level2)933 HWTEST_F(SceneSessionTest4, SetSystemWindowEnableDrag01, Function | SmallTest | Level2)
934 {
935     SessionInfo info;
936     info.abilityName_ = "SetSystemWindowEnableDrag01";
937     info.bundleName_ = "SetSystemWindowEnableDrag01";
938     info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
939     sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
940     sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
941     auto ret = session->SetSystemWindowEnableDrag(true);
942     ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
943 }
944 
945 /**
946  * @tc.name: OnTitleAndDockHoverShowChange01
947  * @tc.desc: normal function
948  * @tc.type: FUNC
949  */
HWTEST_F(SceneSessionTest4, OnTitleAndDockHoverShowChange01, Function | SmallTest | Level2)950 HWTEST_F(SceneSessionTest4, OnTitleAndDockHoverShowChange01, Function | SmallTest | Level2)
951 {
952     SessionInfo info;
953     info.abilityName_ = "OnTitleAndDockHoverShowChange01";
954     info.bundleName_ = "OnTitleAndDockHoverShowChange01";
955     sptr<SceneSession> sceneSession = sptr<MainSession>::MakeSptr(info, nullptr);
956 
957     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
958     property->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
959     sceneSession->SetSessionProperty(property);
960     sceneSession->sessionChangeCallback_ = new SceneSession::SessionChangeCallback();
961     auto result = sceneSession->OnTitleAndDockHoverShowChange(true, true);
962     ASSERT_EQ(result, WSError::WS_OK);
963 }
964 
965 /**
966  * @tc.name: SetAutoStartPiP01
967  * @tc.desc: SetAutoStartPiP
968  * @tc.type: FUNC
969  */
HWTEST_F(SceneSessionTest4, SetAutoStartPiP01, Function | SmallTest | Level2)970 HWTEST_F(SceneSessionTest4, SetAutoStartPiP01, Function | SmallTest | Level2)
971 {
972     SessionInfo info;
973     info.abilityName_ = "SetAutoStartPiP01";
974     info.bundleName_ = "SetAutoStartPiP01";
975     sptr<SceneSession> sceneSession = sptr<MainSession>::MakeSptr(info, nullptr);
976 
977     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
978     property->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
979     sceneSession->SetSessionProperty(property);
980     sceneSession->isTerminating_ = false;
981     auto result = sceneSession->SetAutoStartPiP(true);
982     ASSERT_EQ(result, WSError::WS_OK);
983 }
984 
985 /**
986  * @tc.name: SetAutoStartPiP02
987  * @tc.desc: SetAutoStartPiP
988  * @tc.type: FUNC
989  */
HWTEST_F(SceneSessionTest4, SetAutoStartPiP02, Function | SmallTest | Level2)990 HWTEST_F(SceneSessionTest4, SetAutoStartPiP02, Function | SmallTest | Level2)
991 {
992     SessionInfo info;
993     info.abilityName_ = "SetAutoStartPiP02";
994     info.bundleName_ = "SetAutoStartPiP02";
995     sptr<SceneSession> sceneSession = sptr<MainSession>::MakeSptr(info, nullptr);
996 
997     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
998     property->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
999     sceneSession->SetSessionProperty(property);
1000     sceneSession->isTerminating_ = true;
1001     NotifyAutoStartPiPStatusChangeFunc func = [](bool flag) {
1002         return;
1003     };
1004     sceneSession->autoStartPiPStatusChangeFunc_ = func;
1005     auto result = sceneSession->SetAutoStartPiP(true);
1006     ASSERT_EQ(result, WSError::WS_OK);
1007 }
1008 
1009 /**
1010  * @tc.name: SetAutoStartPiP03
1011  * @tc.desc: SetAutoStartPiP
1012  * @tc.type: FUNC
1013  */
HWTEST_F(SceneSessionTest4, SetAutoStartPiP03, Function | SmallTest | Level2)1014 HWTEST_F(SceneSessionTest4, SetAutoStartPiP03, Function | SmallTest | Level2)
1015 {
1016     SessionInfo info;
1017     info.abilityName_ = "SetAutoStartPiP03";
1018     info.bundleName_ = "SetAutoStartPiP03";
1019     sptr<SceneSession> sceneSession = sptr<MainSession>::MakeSptr(info, nullptr);
1020 
1021     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1022     property->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
1023     sceneSession->SetSessionProperty(property);
1024     sceneSession->isTerminating_ = true;
1025     auto result = sceneSession->SetAutoStartPiP(true);
1026     ASSERT_EQ(result, WSError::WS_OK);
1027 }
1028 
1029 /**
1030  * @tc.name: UpdatePiPControlStatus
1031  * @tc.desc: UpdatePiPControlStatus
1032  * @tc.type: FUNC
1033  */
HWTEST_F(SceneSessionTest4, UpdatePiPControlStatus, Function | SmallTest | Level2)1034 HWTEST_F(SceneSessionTest4, UpdatePiPControlStatus, Function | SmallTest | Level2)
1035 {
1036     SessionInfo info;
1037     info.abilityName_ = "UpdatePiPControlStatus";
1038     info.bundleName_ = "UpdatePiPControlStatus";
1039     auto sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1040     ASSERT_NE(sceneSession, nullptr);
1041     sceneSession->isActive_ = true;
1042 
1043     auto property = sptr<WindowSessionProperty>::MakeSptr();
1044     ASSERT_NE(property, nullptr);
1045     property->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1046     sceneSession->SetSessionProperty(property);
1047 
1048     auto controlType = WsPiPControlType::VIDEO_PLAY_PAUSE;
1049     auto status = WsPiPControlStatus::PLAY;
1050     sceneSession->isTerminating_ = false;
1051     WSError result = sceneSession->UpdatePiPControlStatus(controlType, status);
1052     ASSERT_EQ(result, WSError::WS_OK);
1053 
1054     sceneSession->isTerminating_ = true;
1055     result = sceneSession->UpdatePiPControlStatus(controlType, status);
1056     ASSERT_EQ(result, WSError::WS_OK);
1057 }
1058 
1059 /**
1060  * @tc.name: SetSplitButtonVisible01
1061  * @tc.desc: SetSplitButtonVisible
1062  * @tc.type: FUNC
1063  */
HWTEST_F(SceneSessionTest4, SetSplitButtonVisible01, Function | SmallTest | Level2)1064 HWTEST_F(SceneSessionTest4, SetSplitButtonVisible01, Function | SmallTest | Level2)
1065 {
1066     SessionInfo info;
1067     info.abilityName_ = "SetSplitButtonVisible01";
1068     info.bundleName_ = "SetSplitButtonVisible01";
1069     sptr<SceneSession> sceneSession = sptr<MainSession>::MakeSptr(info, nullptr);
1070 
1071     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1072     property->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
1073     sceneSession->SetSessionProperty(property);
1074     sceneSession->sessionStage_ = nullptr;
1075     auto result = sceneSession->SetSplitButtonVisible(true);
1076     EXPECT_EQ(result, WSError::WS_ERROR_NULLPTR);
1077 }
1078 
1079 /**
1080  * @tc.name: SetSplitButtonVisible02
1081  * @tc.desc: SetSplitButtonVisible
1082  * @tc.type: FUNC
1083  */
HWTEST_F(SceneSessionTest4, SetSplitButtonVisible02, Function | SmallTest | Level2)1084 HWTEST_F(SceneSessionTest4, SetSplitButtonVisible02, Function | SmallTest | Level2)
1085 {
1086     SessionInfo info;
1087     info.abilityName_ = "SetSplitButtonVisible02";
1088     info.bundleName_ = "SetSplitButtonVisible02";
1089     sptr<SceneSession> sceneSession = sptr<MainSession>::MakeSptr(info, nullptr);
1090 
1091     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1092     property->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
1093     sceneSession->SetSessionProperty(property);
1094     sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
1095     sceneSession->sessionStage_ = mockSessionStage;
1096     auto result = sceneSession->SetSplitButtonVisible(true);
1097     EXPECT_EQ(result, WSError::WS_OK);
1098 }
1099 
1100 /**
1101  * @tc.name: SetMovable01
1102  * @tc.desc: SetMovable
1103  * @tc.type: FUNC
1104  */
HWTEST_F(SceneSessionTest4, SetMovable01, Function | SmallTest | Level2)1105 HWTEST_F(SceneSessionTest4, SetMovable01, Function | SmallTest | Level2)
1106 {
1107     SessionInfo info;
1108     info.abilityName_ = "SetMovable01";
1109     info.bundleName_ = "SetMovable01";
1110 
1111     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1112 
1113     sceneSession->SetMovable(true);
1114     sceneSession->leashWinSurfaceNode_ = nullptr;
1115     SessionEvent event = SessionEvent::EVENT_START_MOVE;
1116     sceneSession->moveDragController_ = new MoveDragController(1);
1117     sceneSession->SetMovable(true);
1118     sceneSession->sessionChangeCallback_ = new SceneSession::SessionChangeCallback();
1119     sceneSession->OnSessionEvent(event);
1120     sceneSession->moveDragController_->isStartDrag_ = true;
1121     sceneSession->sessionChangeCallback_ = new SceneSession::SessionChangeCallback();
1122     ASSERT_NE(sceneSession->sessionChangeCallback_, nullptr);
1123     auto result = sceneSession->OnSessionEvent(event);
1124     ASSERT_EQ(result, WSError::WS_OK);
1125 }
1126 
1127 /**
1128  * @tc.name: TerminateSession01
1129  * @tc.desc: TerminateSession
1130  * @tc.type: FUNC
1131  */
HWTEST_F(SceneSessionTest4, TerminateSession01, Function | SmallTest | Level2)1132 HWTEST_F(SceneSessionTest4, TerminateSession01, Function | SmallTest | Level2)
1133 {
1134     SessionInfo info;
1135     info.abilityName_ = "TerminateSession01";
1136     info.bundleName_ = "TerminateSession01";
1137 
1138     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1139 
1140     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1141     sptr<AAFwk::SessionInfo> abilitySessionInfo = new AAFwk::SessionInfo();
1142     sceneSession->isTerminating_ = true;
1143     ASSERT_EQ(WSError::WS_OK, sceneSession->TerminateSession(abilitySessionInfo));
1144 
1145     sceneSession->isTerminating_ = false;
1146     NotifyTerminateSessionFunc func = [sceneSession](const SessionInfo& info) {
1147         return;
1148     };
1149     sceneSession->SetTerminateSessionListener(func);
1150     ASSERT_EQ(WSError::WS_OK, sceneSession->TerminateSession(abilitySessionInfo));
1151 }
1152 
1153 /**
1154  * @tc.name: SetWindowFlags01
1155  * @tc.desc: SetWindowFlags
1156  * @tc.type: FUNC
1157  */
HWTEST_F(SceneSessionTest4, SetWindowFlags01, Function | SmallTest | Level2)1158 HWTEST_F(SceneSessionTest4, SetWindowFlags01, Function | SmallTest | Level2)
1159 {
1160     SessionInfo info;
1161     info.abilityName_ = "SetWindowFlags01";
1162     info.bundleName_ = "SetWindowFlags01";
1163 
1164     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1165     sceneSession->SetSessionProperty(nullptr);
1166     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1167     sceneSession->SetWindowFlags(property);
1168     ASSERT_EQ(0, property->GetWindowFlags());
1169 }
1170 
1171 /**
1172  * @tc.name: SetWindowFlags02
1173  * @tc.desc: SetWindowFlags
1174  * @tc.type: FUNC
1175  */
HWTEST_F(SceneSessionTest4, SetWindowFlags02, Function | SmallTest | Level2)1176 HWTEST_F(SceneSessionTest4, SetWindowFlags02, Function | SmallTest | Level2)
1177 {
1178     SessionInfo info;
1179     info.abilityName_ = "SetWindowFlags02";
1180     info.bundleName_ = "SetWindowFlags02";
1181 
1182     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1183     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1184     property->SetWindowFlags(2);
1185     sceneSession->SetSessionProperty(property);
1186 
1187     sptr<WindowSessionProperty> property2 = sptr<WindowSessionProperty>::MakeSptr();
1188     property2->SetWindowFlags(2);
1189     property2->SetSystemCalling(false);
1190 
1191     sceneSession->SetWindowFlags(property2);
1192     ASSERT_EQ(2, sceneSession->GetSessionProperty()->GetWindowFlags());
1193 }
1194 
1195 /**
1196  * @tc.name: SetWindowFlags03
1197  * @tc.desc: SetWindowFlags
1198  * @tc.type: FUNC
1199  */
HWTEST_F(SceneSessionTest4, SetWindowFlags03, Function | SmallTest | Level2)1200 HWTEST_F(SceneSessionTest4, SetWindowFlags03, Function | SmallTest | Level2)
1201 {
1202     SessionInfo info;
1203     info.abilityName_ = "SetWindowFlags03";
1204     info.bundleName_ = "SetWindowFlags03";
1205 
1206     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1207     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1208     property->SetWindowFlags(2);
1209     sceneSession->SetSessionProperty(property);
1210 
1211     sptr<WindowSessionProperty> property2 = sptr<WindowSessionProperty>::MakeSptr();
1212     property2->SetWindowFlags(2);
1213     property2->SetSystemCalling(true);
1214 
1215     sceneSession->SetWindowFlags(property2);
1216     ASSERT_EQ(2, sceneSession->GetSessionProperty()->GetWindowFlags());
1217 }
1218 
1219 /**
1220  * @tc.name: UpdateSessionPropertyByAction02
1221  * @tc.desc: UpdateSessionPropertyByAction function
1222  * @tc.type: FUNC
1223  */
HWTEST_F(SceneSessionTest4, UpdateSessionPropertyByAction02, Function | SmallTest | Level2)1224 HWTEST_F(SceneSessionTest4, UpdateSessionPropertyByAction02, Function | SmallTest | Level2)
1225 {
1226     SessionInfo info;
1227     info.abilityName_ = "UpdateSessionPropertyByAction02";
1228     info.bundleName_ = "UpdateSessionPropertyByAction02";
1229     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1230 
1231     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1232     sceneSession->SetSessionProperty(property);
1233     WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_MAIN_WINDOW_TOPMOST;
1234     ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, sceneSession->UpdateSessionPropertyByAction(property, action));
1235 }
1236 
1237 /**
1238  * @tc.name: IsMovable01
1239  * @tc.desc: IsMovable
1240  * @tc.type: FUNC
1241  */
HWTEST_F(SceneSessionTest4, isMovable01, Function | SmallTest | Level2)1242 HWTEST_F(SceneSessionTest4, isMovable01, Function | SmallTest | Level2)
1243 {
1244     SessionInfo info;
1245     info.abilityName_ = "isMovable01";
1246     info.bundleName_ = "isMovable01";
1247     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1248     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1249     sceneSession->SetSessionProperty(property);
1250     ASSERT_EQ(false, sceneSession->IsMovable());
1251 }
1252 
1253 /**
1254  * @tc.name: IsMovable02
1255  * @tc.desc: IsMovable
1256  * @tc.type: FUNC
1257  */
HWTEST_F(SceneSessionTest4, IsMovable02, Function | SmallTest | Level2)1258 HWTEST_F(SceneSessionTest4, IsMovable02, Function | SmallTest | Level2)
1259 {
1260     SessionInfo info;
1261     info.abilityName_ = "IsMovable02";
1262     info.bundleName_ = "IsMovable02";
1263     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1264     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1265     sceneSession->SetSessionProperty(property);
1266     sceneSession->moveDragController_ = sptr<MoveDragController>::MakeSptr(2024);
1267     ASSERT_EQ(WSError::WS_DO_NOTHING, sceneSession->UpdateFocus(false));
1268     ASSERT_EQ(false, sceneSession->IsMovable());
1269     ASSERT_EQ(WSError::WS_OK, sceneSession->UpdateFocus(true));
1270 }
1271 
1272 /**
1273  * @tc.name: IsMovable03
1274  * @tc.desc: IsMovable
1275  * @tc.type: FUNC
1276  */
HWTEST_F(SceneSessionTest4, IsMovable03, Function | SmallTest | Level2)1277 HWTEST_F(SceneSessionTest4, IsMovable03, Function | SmallTest | Level2)
1278 {
1279     SessionInfo info;
1280     info.abilityName_ = "IsMovable03";
1281     info.bundleName_ = "IsMovable03";
1282     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1283     sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1284     sceneSession->SetSessionProperty(nullptr);
1285     sceneSession->moveDragController_ = sptr<MoveDragController>::MakeSptr(2024);
1286     ASSERT_EQ(WSError::WS_OK, sceneSession->UpdateFocus(true));
1287     ASSERT_EQ(false, sceneSession->IsMovable());
1288 }
1289 }
1290 }
1291 }
1292