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 */
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 sceneSession->HandleActionUpdateStatusProps(property, sceneSession, action);
82 sceneSession->HandleActionUpdateNavigationProps(property, sceneSession, action);
83 sceneSession->HandleActionUpdateNavigationIndicatorProps(property, sceneSession, action);
84 sceneSession->HandleActionUpdateFlags(property, sceneSession, action);
85
86 auto ret = sceneSession->HandleActionUpdateFlags(property, sceneSession, action);
87 ASSERT_NE(ret, WMError::WM_ERROR_NOT_SYSTEM_APP);
88 OHOS::Rosen::WindowSessionProperty windowSessionProperty;
89 windowSessionProperty.isSystemCalling_ = {true};
90 sceneSession->HandleActionUpdateFlags(property, sceneSession, action);
91 windowSessionProperty.isSystemCalling_ = {true};
92 OHOS::Rosen::Session session(info);
93 session.property_ = new WindowSessionProperty();
94 sceneSession->HandleActionUpdateFlags(property, sceneSession, action);
95 }
96
97 /**
98 * @tc.name: HandleActionUpdateTouchHotArea
99 * @tc.desc: normal function
100 * @tc.type: FUNC
101 */
102 HWTEST_F(SceneSessionTest4, HandleActionUpdateTouchHotArea, Function | SmallTest | Level2)
103 {
104 SessionInfo info;
105 sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
106 ASSERT_NE(nullptr, sceneSession);
107 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
108 ASSERT_NE(nullptr, property);
109 WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
110 sceneSession->HandleActionUpdateTouchHotArea(property, sceneSession, action);
111 OHOS::Rosen::Session session(info);
112 session.property_ = new WindowSessionProperty();
113 sceneSession->HandleActionUpdateTouchHotArea(property, sceneSession, action);
114
115 sceneSession->SetSessionProperty(nullptr);
116 sceneSession->HandleActionUpdateTouchHotArea(property, sceneSession, action);
117 }
118
119 /**
120 * @tc.name: HandleActionUpdateDecorEnable
121 * @tc.desc: normal function
122 * @tc.type: FUNC
123 */
124 HWTEST_F(SceneSessionTest4, HandleActionUpdateDecorEnable, Function | SmallTest | Level2)
125 {
126 SessionInfo info;
127 sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
128 ASSERT_NE(nullptr, sceneSession);
129 WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
130
131 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
132 ASSERT_NE(nullptr, property);
133 OHOS::Rosen::Session session(info);
134 session.property_ = nullptr;
135 sceneSession->HandleActionUpdateDecorEnable(property, sceneSession, action);
136 session.property_ = new WindowSessionProperty();
137 sceneSession->HandleActionUpdateDecorEnable(property, sceneSession, action);
138
139 OHOS::Rosen::WindowSessionProperty windowSessionProperty;
140 windowSessionProperty.isSystemCalling_ = {true};
141 auto ret = sceneSession->HandleActionUpdateDecorEnable(property, sceneSession, action);
142 ASSERT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, ret);
143 }
144
145 /**
146 * @tc.name: HandleActionUpdateWindowLimits
147 * @tc.desc: normal function
148 * @tc.type: FUNC
149 */
150 HWTEST_F(SceneSessionTest4, HandleActionUpdateWindowLimits, Function | SmallTest | Level2)
151 {
152 SessionInfo info;
153 sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
154 ASSERT_NE(nullptr, sceneSession);
155 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
156 ASSERT_NE(nullptr, property);
157
158 WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
159 OHOS::Rosen::Session session(info);
160 session.property_ = nullptr;
161 sceneSession->HandleActionUpdateWindowLimits(property, sceneSession, action);
162 session.property_ = new WindowSessionProperty();
163 sceneSession->HandleActionUpdateWindowLimits(property, sceneSession, action);
164 }
165
166 /**
167 * @tc.name: HandleActionUpdateDragenabled
168 * @tc.desc: normal function
169 * @tc.type: FUNC
170 */
171 HWTEST_F(SceneSessionTest4, HandleActionUpdateDragenabled, Function | SmallTest | Level2)
172 {
173 SessionInfo info;
174 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
175 WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ASPECT_RATIO;
176 OHOS::Rosen::Session session(info);
177 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
178 session.property_ = property;
179
180 WMError res = sceneSession->HandleActionUpdateDragenabled(property, sceneSession, action);
181 ASSERT_EQ(WMError::WM_OK, res);
182 }
183
184 /**
185 * @tc.name: HandleActionUpdateRaiseenabled
186 * @tc.desc: normal function
187 * @tc.type: FUNC
188 */
189 HWTEST_F(SceneSessionTest4, HandleActionUpdateRaiseenabled, Function | SmallTest | Level2)
190 {
191 ASSERT_NE(nullptr, sceneSession);
192 ASSERT_NE(nullptr, property);
193 WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_ANIMATION_FLAG;
194 sceneSession->HandleActionUpdateRaiseenabled(property, sceneSession, action);
195
196 OHOS::Rosen::WindowSessionProperty windowSessionProperty;
197 windowSessionProperty.isSystemCalling_ = {true};
198 sceneSession->HandleActionUpdateRaiseenabled(property, sceneSession, action);
199
200 windowSessionProperty.isSystemCalling_ = {true};
201 OHOS::Rosen::Session session(info);
202 session.property_ = new WindowSessionProperty();
203 sceneSession->HandleActionUpdateRaiseenabled(property, sceneSession, action);
204
205 sceneSession->HandleActionUpdateHideNonSystemFloatingWindows(property, sceneSession, action);
206 }
207
208 /**
209 * @tc.name: HandleActionUpdateTextfieldAvoidInfo
210 * @tc.desc: normal function
211 * @tc.type: FUNC
212 */
213 HWTEST_F(SceneSessionTest4, HandleActionUpdateTextfieldAvoidInfo, Function | SmallTest | Level2)
214 {
215 ASSERT_NE(nullptr, sceneSession);
216 ASSERT_NE(nullptr, property);
217 sceneSession->HandleActionUpdateTextfieldAvoidInfo(property, sceneSession, action);
218 sceneSession->HandleActionUpdateWindowMask(property, sceneSession, action);
219
220 OHOS::Rosen::Session session(info);
221 session.property_ = new WindowSessionProperty();
222 sceneSession->HandleActionUpdateTextfieldAvoidInfo(property, sceneSession, action);
223 sceneSession->HandleActionUpdateWindowMask(property, sceneSession, action);
224 sceneSession->HandleActionUpdateTopmost(property, sceneSession, action);
225
226 SessionInfo info;
227 sptr<SceneSession> sceneSession1 = new (std::nothrow) SceneSession(info, nullptr);
228 ASSERT_NE(nullptr, sceneSession1);
229 sceneSession1->SetSessionProperty(nullptr);
230 sceneSession1->HandleActionUpdateTextfieldAvoidInfo(property, sceneSession1, action);
231 sceneSession1->HandleActionUpdateWindowMask(property, sceneSession1, action);
232 }
233
234 /**
235 * @tc.name: SetWindowFlags
236 * @tc.desc: normal function
237 * @tc.type: FUNC
238 */
239 HWTEST_F(SceneSessionTest4, SetWindowFlags, Function | SmallTest | Level2)
240 {
241 ASSERT_NE(nullptr, sceneSession);
242 ASSERT_NE(nullptr, property);
243 sptr<SceneSession> sceneSession1 = nullptr;
244 sceneSession->SetWindowFlags(sceneSession1, property);
245 sceneSession1 = new (std::nothrow) SceneSession(info, nullptr);
246 ASSERT_NE(nullptr, sceneSession1);
247 sceneSession->SetWindowFlags(sceneSession1, property);
248
249 OHOS::Rosen::Session session(info);
250 session.property_ = new WindowSessionProperty();
251 sceneSession->SetWindowFlags(sceneSession1, property);
252 sceneSession->NotifySessionChangeByActionNotifyManager(sceneSession1, property, action);
253
254 session.property_ = nullptr;
255 sceneSession->SetWindowFlags(sceneSession1, property);
256 sceneSession->sessionChangeByActionNotifyManagerFunc_ = [](
257 const sptr<SceneSession>& sceneSession,
258 const sptr<WindowSessionProperty>& property, WSPropertyChangeAction action
__anon5bf3b6d60202( const sptr<SceneSession>& sceneSession, const sptr<WindowSessionProperty>& property, WSPropertyChangeAction action )259 ){};
260 sceneSession->NotifySessionChangeByActionNotifyManager(sceneSession1, property, action);
261 }
262
263 /**
264 * @tc.name: SetSkipDraw
265 * @tc.desc: SetSkipDraw function
266 * @tc.type: FUNC
267 */
268 HWTEST_F(SceneSessionTest4, SetSkipDraw, Function | SmallTest | Level2)
269 {
270 SessionInfo info;
271 info.abilityName_ = "SetSkipDraw";
272 info.bundleName_ = "SetSkipDraw";
273 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
274 EXPECT_NE(nullptr, session);
275 struct RSSurfaceNodeConfig config;
276 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
277 session->surfaceNode_ = surfaceNode;
278 session->SetLeashWinSurfaceNode(nullptr);
279 session->SetSkipDraw(true);
280 session->SetLeashWinSurfaceNode(surfaceNode);
281 EXPECT_EQ(surfaceNode, session->GetLeashWinSurfaceNode());
282 session->SetSkipDraw(true);
283 }
284
285 /**
286 * @tc.name: SetScale
287 * @tc.desc: SetScale function
288 * @tc.type: FUNC
289 */
290 HWTEST_F(SceneSessionTest4, SetScale, Function | SmallTest | Level2)
291 {
292 SessionInfo info;
293 info.abilityName_ = "SetScale";
294 info.bundleName_ = "SetScale";
295 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
296 EXPECT_NE(nullptr, session);
297 session->Session::SetScale(1.0f, 2.0f, 3.0f, 4.0f);
298 session->sessionStage_ = nullptr;
299 session->SetScale(5.0f, 2.0f, 3.0f, 4.0f);
300 sptr<SceneSession::SpecificSessionCallback> specificCallback =
301 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
__anon5bf3b6d60302(int32_t persistentId, WindowUpdateType type) 302 NotifyWindowInfoUpdateCallback func = [](int32_t persistentId, WindowUpdateType type) {
303 return;
304 };
305 specificCallback->onWindowInfoUpdate_ = func;
306 session->specificCallback_ = specificCallback;
307 session->SetScale(5.0f, 5.0f, 3.0f, 4.0f);
308 session->SetScale(5.0f, 5.0f, 5.0f, 4.0f);
309 session->SetScale(5.0f, 5.0f, 5.0f, 5.0f);
310 session->SetScale(5.0f, 5.0f, 5.0f, 5.0f);
311 EXPECT_EQ(5.0f, session->GetScaleX());
312 EXPECT_EQ(5.0f, session->GetScaleY());
313 EXPECT_EQ(5.0f, session->GetPivotX());
314 EXPECT_EQ(5.0f, session->GetPivotY());
315
316 session->sessionStage_ = new SessionStageMocker();
317 EXPECT_NE(nullptr, session->sessionStage_);
318 session->SetScale(5.0f, 5.0f, 5.0f, 5.0f);
319 EXPECT_EQ(5.0f, session->GetPivotY());
320 }
321
322 /**
323 * @tc.name: RequestSessionBack
324 * @tc.desc: RequestSessionBack function
325 * @tc.type: FUNC
326 */
327 HWTEST_F(SceneSessionTest4, RequestSessionBack, Function | SmallTest | Level2)
328 {
329 SessionInfo info;
330 info.abilityName_ = "RequestSessionBack";
331 info.bundleName_ = "RequestSessionBack";
332 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
333 EXPECT_NE(nullptr, session);
__anon5bf3b6d60402(const bool needMoveToBackground) 334 NotifyBackPressedFunc func = [](const bool needMoveToBackground) {
335 return;
336 };
337 session->backPressedFunc_ = func;
338 EXPECT_EQ(WSError::WS_OK, session->RequestSessionBack(true));
339 }
340
341 /**
342 * @tc.name: SetSurfaceBounds
343 * @tc.desc: SetSurfaceBounds function
344 * @tc.type: FUNC
345 */
346 HWTEST_F(SceneSessionTest4, SetSurfaceBounds, Function | SmallTest | Level2)
347 {
348 SessionInfo info;
349 info.abilityName_ = "SetSurfaceBounds";
350 info.bundleName_ = "SetSurfaceBounds";
351 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
352 EXPECT_NE(nullptr, session);
353 WSRect rect;
354 struct RSSurfaceNodeConfig config;
355 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
356 session->surfaceNode_ = surfaceNode;
357 session->SetSurfaceBounds(rect);
358 session->SetLeashWinSurfaceNode(surfaceNode);
359 session->SetSurfaceBounds(rect);
360 EXPECT_NE(nullptr, session->GetLeashWinSurfaceNode());
361 }
362
363 /**
364 * @tc.name: SetFloatingScale
365 * @tc.desc: SetFloatingScale function
366 * @tc.type: FUNC
367 */
368 HWTEST_F(SceneSessionTest4, SetFloatingScale, Function | SmallTest | Level2)
369 {
370 SessionInfo info;
371 info.abilityName_ = "SetFloatingScale";
372 info.bundleName_ = "SetFloatingScale";
373 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
374 EXPECT_NE(nullptr, session);
375 session->floatingScale_ = 3.14f;
376 session->SetFloatingScale(2.176f);
377 session->SetFloatingScale(3.14f);
378 EXPECT_EQ(nullptr, session->specificCallback_);
379 }
380
381 /**
382 * @tc.name: GetSessionSnapshotFilePath
383 * @tc.desc: GetSessionSnapshotFilePath function
384 * @tc.type: FUNC
385 */
386 HWTEST_F(SceneSessionTest4, GetSessionSnapshotFilePath, Function | SmallTest | Level2)
387 {
388 SessionInfo info;
389 info.abilityName_ = "GetSessionSnapshotFilePath";
390 info.bundleName_ = "GetSessionSnapshotFilePath";
391 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
392 session->Session::SetSessionState(SessionState::STATE_DISCONNECT);
393 session->scenePersistence_ = sptr<ScenePersistence>::MakeSptr("GetSessionSnapshotFilePath", 1);
394 EXPECT_EQ("GetSessionSnapshotFilePath_1.astc", session->GetSessionSnapshotFilePath());
395
396 session->SetSessionState(SessionState::STATE_BACKGROUND);
397 EXPECT_EQ("GetSessionSnapshotFilePath_1.astc", session->GetSessionSnapshotFilePath());
398 }
399
400 /**
401 * @tc.name: SetRequestedOrientation
402 * @tc.desc: SetRequestedOrientation function
403 * @tc.type: FUNC
404 */
405 HWTEST_F(SceneSessionTest4, SetRequestedOrientation, Function | SmallTest | Level2)
406 {
407 SessionInfo info;
408 info.abilityName_ = "SetRequestedOrientation";
409 info.bundleName_ = "SetRequestedOrientation";
410 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
411 Orientation orientation { Orientation::BEGIN };
412 session->sessionChangeCallback_ = nullptr;
413 session->SetRequestedOrientation(orientation);
414 session->onRequestedOrientationChange_ = nullptr;
415 session->SetRequestedOrientation(orientation);
__anon5bf3b6d60502(uint32_t orientation) 416 NotifyReqOrientationChangeFunc func = [](uint32_t orientation) {
417 return;
418 };
419 session->onRequestedOrientationChange_ = func;
420 session->SetRequestedOrientation(orientation);
421 EXPECT_NE(nullptr, session->onRequestedOrientationChange_);
422 }
423
424 /**
425 * @tc.name: UpdateSessionPropertyByAction
426 * @tc.desc: UpdateSessionPropertyByAction function
427 * @tc.type: FUNC
428 */
429 HWTEST_F(SceneSessionTest4, UpdateSessionPropertyByAction, Function | SmallTest | Level2)
430 {
431 SessionInfo info;
432 info.abilityName_ = "UpdateSessionPropertyByAction";
433 info.bundleName_ = "UpdateSessionPropertyByAction";
434 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
435 ASSERT_NE(nullptr, sceneSession);
436 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
437 ASSERT_NE(nullptr, property);
438 WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE;
439 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, sceneSession->UpdateSessionPropertyByAction(nullptr, action));
440
441 sceneSession->SetSessionProperty(nullptr);
442 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, sceneSession->UpdateSessionPropertyByAction(property, action));
443
444 sceneSession->SetSessionProperty(property);
445 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, sceneSession->UpdateSessionPropertyByAction(property, action));
446
447 action = WSPropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON;
448 EXPECT_EQ(WMError::WM_OK, sceneSession->UpdateSessionPropertyByAction(property, action));
449 }
450
451 /**
452 * @tc.name: HandleUpdatePropertyByAction
453 * @tc.desc: HandleUpdatePropertyByAction function
454 * @tc.type: FUNC
455 */
456 HWTEST_F(SceneSessionTest4, HandleUpdatePropertyByAction, Function | SmallTest | Level2)
457 {
458 SessionInfo info;
459 info.abilityName_ = "HandleUpdatePropertyByAction";
460 info.bundleName_ = "HandleUpdatePropertyByAction";
461 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
462 ASSERT_NE(nullptr, sceneSession);
463 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
464 ASSERT_NE(nullptr, property);
465 WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_MODE;
466 sceneSession->HandleUpdatePropertyByAction(property, sceneSession, action);
467 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, sceneSession->HandleUpdatePropertyByAction(nullptr, sceneSession, action));
468 }
469
470 /**
471 * @tc.name: ProcessUpdatePropertyByAction1
472 * @tc.desc: ProcessUpdatePropertyByAction1 function
473 * @tc.type: FUNC
474 */
475 HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction1, Function | SmallTest | Level2)
476 {
477 SessionInfo info;
478 info.abilityName_ = "ProcessUpdatePropertyByAction1";
479 info.bundleName_ = "ProcessUpdatePropertyByAction1";
480 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
481 ASSERT_NE(nullptr, sceneSession);
482 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
483 ASSERT_NE(nullptr, property);
484
485 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
486 WSPropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON));
487
488 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
489 WSPropertyChangeAction::ACTION_UPDATE_KEEP_SCREEN_ON));
490
491 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
492 WSPropertyChangeAction::ACTION_UPDATE_FOCUSABLE));
493
494 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
495 WSPropertyChangeAction::ACTION_UPDATE_TOUCHABLE));
496
497 sceneSession->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
498 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
499 WSPropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS));
500
501 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
502 sceneSession->state_ = SessionState::STATE_END;
503 EXPECT_EQ(WMError::WM_ERROR_INVALID_SESSION, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
504 WSPropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS));
505
506 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
507 sceneSession->state_ = SessionState::STATE_ACTIVE;
508 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
509 WSPropertyChangeAction::ACTION_UPDATE_SET_BRIGHTNESS));
510
511 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
512 WSPropertyChangeAction::ACTION_UPDATE_ORIENTATION));
513
514 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
515 WSPropertyChangeAction::ACTION_UPDATE_PRIVACY_MODE));
516
517 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
518 WSPropertyChangeAction::ACTION_UPDATE_SYSTEM_PRIVACY_MODE));
519
520 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
521 WSPropertyChangeAction::ACTION_UPDATE_SNAPSHOT_SKIP));
522 }
523
524 /**
525 * @tc.name: ProcessUpdatePropertyByAction2
526 * @tc.desc: ProcessUpdatePropertyByAction2 function
527 * @tc.type: FUNC
528 */
529 HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction2, Function | SmallTest | Level2)
530 {
531 SessionInfo info;
532 info.abilityName_ = "ProcessUpdatePropertyByAction2";
533 info.bundleName_ = "ProcessUpdatePropertyByAction2";
534 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
535 ASSERT_NE(nullptr, sceneSession);
536 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
537 ASSERT_NE(nullptr, property);
538
539 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
540 WSPropertyChangeAction::ACTION_UPDATE_MAXIMIZE_STATE));
541
542 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
543 WSPropertyChangeAction::ACTION_UPDATE_OTHER_PROPS));
544
545 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
546 WSPropertyChangeAction::ACTION_UPDATE_STATUS_PROPS));
547
548 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
549 WSPropertyChangeAction::ACTION_UPDATE_NAVIGATION_PROPS));
550
551 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
552 WSPropertyChangeAction::ACTION_UPDATE_NAVIGATION_INDICATOR_PROPS));
553
554 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
555 WSPropertyChangeAction::ACTION_UPDATE_FLAGS));
556
557 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
558 WSPropertyChangeAction::ACTION_UPDATE_MODE));
559
560 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
561 WSPropertyChangeAction::ACTION_UPDATE_ANIMATION_FLAG));
562
563 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
564 WSPropertyChangeAction::ACTION_UPDATE_TOUCH_HOT_AREA));
565
566 property->SetSystemCalling(false);
567 EXPECT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
568 WSPropertyChangeAction::ACTION_UPDATE_DECOR_ENABLE));
569
570 property->SetSystemCalling(true);
571 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
572 WSPropertyChangeAction::ACTION_UPDATE_DECOR_ENABLE));
573 }
574
575 /**
576 * @tc.name: ProcessUpdatePropertyByAction3
577 * @tc.desc: ProcessUpdatePropertyByAction3 function
578 * @tc.type: FUNC
579 */
580 HWTEST_F(SceneSessionTest4, ProcessUpdatePropertyByAction3, Function | SmallTest | Level2)
581 {
582 SessionInfo info;
583 info.abilityName_ = "ProcessUpdatePropertyByAction3";
584 info.bundleName_ = "ProcessUpdatePropertyByAction3";
585 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
586 ASSERT_NE(nullptr, sceneSession);
587 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
588 ASSERT_NE(nullptr, property);
589
590 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
591 WSPropertyChangeAction::ACTION_UPDATE_WINDOW_LIMITS));
592
593 property->SetSystemCalling(false);
594 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
595 WSPropertyChangeAction::ACTION_UPDATE_DRAGENABLED));
596
597 property->SetSystemCalling(true);
598 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
599 WSPropertyChangeAction::ACTION_UPDATE_DRAGENABLED));
600
601 sceneSession->property_ = property;
602 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
603 WSPropertyChangeAction::ACTION_UPDATE_DRAGENABLED));
604
605 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
606 WSPropertyChangeAction::ACTION_UPDATE_RAISEENABLED));
607
608 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
609 WSPropertyChangeAction::ACTION_UPDATE_HIDE_NON_SYSTEM_FLOATING_WINDOWS));
610
611 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
612 WSPropertyChangeAction::ACTION_UPDATE_TEXTFIELD_AVOID_INFO));
613
614 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
615 WSPropertyChangeAction::ACTION_UPDATE_WINDOW_MASK));
616
617 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
618 WSPropertyChangeAction::ACTION_UPDATE_TOPMOST));
619
620 property->SetSystemCalling(false);
621 EXPECT_EQ(WMError::WM_ERROR_NOT_SYSTEM_APP, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
622 WSPropertyChangeAction::ACTION_UPDATE_MODE_SUPPORT_INFO));
623
624 property->SetSystemCalling(true);
625 EXPECT_EQ(WMError::WM_OK, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
626 WSPropertyChangeAction::ACTION_UPDATE_MODE_SUPPORT_INFO));
627
628 EXPECT_EQ(WMError::WM_DO_NOTHING, sceneSession->ProcessUpdatePropertyByAction(property, sceneSession,
629 WSPropertyChangeAction::ACTION_UPDATE_RECT));
630 }
631
632 /**
633 * @tc.name: HandleSpecificSystemBarProperty
634 * @tc.desc: HandleSpecificSystemBarProperty
635 * @tc.type: FUNC
636 */
637 HWTEST_F(SceneSessionTest4, HandleSpecificSystemBarProperty, Function | SmallTest | Level2)
638 {
639 SessionInfo info;
640 info.abilityName_ = "HandleSpecificSystemBarProperty";
641 info.bundleName_ = "HandleSpecificSystemBarProperty";
642 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
643 ASSERT_NE(nullptr, sceneSession);
644 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
645 ASSERT_NE(nullptr, property);
646 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
647 sceneSession->HandleSpecificSystemBarProperty(type, property, sceneSession);
648 }
649
650 /**
651 * @tc.name: SetWindowFlags1
652 * @tc.desc: SetWindowFlags1
653 * @tc.type: FUNC
654 */
655 HWTEST_F(SceneSessionTest4, SetWindowFlags1, Function | SmallTest | Level2)
656 {
657 SessionInfo info;
658 info.abilityName_ = "SetWindowFlags1";
659 info.bundleName_ = "SetWindowFlags1";
660 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
661 ASSERT_NE(nullptr, sceneSession);
662 sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
663 ASSERT_NE(nullptr, property);
664 sptr<WindowSessionProperty> sessionProperty = new (std::nothrow) WindowSessionProperty();
665 ASSERT_NE(nullptr, sessionProperty);
666 sceneSession->SetWindowFlags(sceneSession, property);
667 sceneSession->property_ = sessionProperty;
668 property->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_PARENT_LIMIT));
669 sceneSession->property_->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
670 sceneSession->SetWindowFlags(sceneSession, property);
671 property->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE));
672 sceneSession->property_->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK));
673 sceneSession->SetWindowFlags(sceneSession, property);
674 }
675
676 /**
677 * @tc.name: SetGestureBackEnabled
678 * @tc.desc: SetGestureBackEnabled
679 * @tc.type: FUNC
680 */
681 HWTEST_F(SceneSessionTest4, SetGestureBackEnabled, Function | SmallTest | Level2)
682 {
683 SessionInfo info;
684 info.abilityName_ = "SetGestureBackEnabled";
685 info.bundleName_ = "SetGestureBackEnabled";
686 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
687 ASSERT_NE(nullptr, sceneSession);
688 sceneSession->isEnableGestureBack_ = false;
689 EXPECT_EQ(WMError::WM_OK, sceneSession->SetGestureBackEnabled(false));
690 sceneSession->specificCallback_ = new SceneSession::SpecificSessionCallback();
691 EXPECT_NE(nullptr, sceneSession->specificCallback_);
__anon5bf3b6d60602(int32_t persistentId) 692 auto func = [sceneSession](int32_t persistentId) {
693 return;
694 };
695 sceneSession->specificCallback_->onUpdateGestureBackEnabled_ = func;
696 EXPECT_EQ(WMError::WM_OK, sceneSession->SetGestureBackEnabled(true));
697 EXPECT_EQ(true, sceneSession->GetGestureBackEnabled());
698 }
699
700 /**
701 * @tc.name: SetIsLayoutFullScreen
702 * @tc.desc: SetIsLayoutFullScreen Test
703 * @tc.type: FUNC
704 */
705 HWTEST_F(SceneSessionTest4, SetIsLayoutFullScreen, Function | SmallTest | Level2)
706 {
707 SessionInfo info;
708 info.abilityName_ = "SetIsLayoutFullScreen";
709 info.bundleName_ = "SetIsLayoutFullScreen";
710 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
711 ASSERT_NE(session, nullptr);
712 session->SetIsLayoutFullScreen(true);
713 EXPECT_EQ(session->IsLayoutFullScreen(), true);
714 }
715
716 /**
717 * @tc.name: IsLayoutFullScreen
718 * @tc.desc: IsLayoutFullScreen Test
719 * @tc.type: FUNC
720 */
721 HWTEST_F(SceneSessionTest4, IsLayoutFullScreen, Function | SmallTest | Level2)
722 {
723 SessionInfo info;
724 info.abilityName_ = "IsLayoutFullScreen";
725 info.bundleName_ = "IsLayoutFullScreen";
726 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
727 ASSERT_NE(session, nullptr);
728 EXPECT_EQ(session->IsLayoutFullScreen(), false);
729 }
730
731 /**
732 * @tc.name: UpdateAllModalUIExtensions
733 * @tc.desc: UpdateAllModalUIExtensions Test
734 * @tc.type: FUNC
735 */
736 HWTEST_F(SceneSessionTest4, UpdateAllModalUIExtensions, Function | SmallTest | Level2)
737 {
738 SessionInfo info;
739 info.abilityName_ = "UpdateAllModalUIExtensions";
740 info.bundleName_ = "UpdateAllModalUIExtensions";
741 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
742 EXPECT_NE(session, nullptr);
743
744 struct RSSurfaceNodeConfig config;
745 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
746 session->surfaceNode_ = surfaceNode;
747 WSRect globalRect = { 100, 100, 100, 100 };
748 session->SetSessionGlobalRect(globalRect);
749
750 Rect windowRect = { 100, 100, 100, 100 };
751 Rect uiExtRect = { 0, 0, 100, 100 };
752 ExtensionWindowEventInfo extensionInfo { 1, 1, windowRect, uiExtRect, false };
753 ExtensionWindowEventInfo extensionInfo2 { 2, 2, windowRect, uiExtRect, true };
754 session->modalUIExtensionInfoList_.push_back(extensionInfo);
755 session->modalUIExtensionInfoList_.push_back(extensionInfo2);
756
757 WSRect newGlobalRect = { 150, 150, 100, 100 };
758 session->UpdateAllModalUIExtensions(newGlobalRect);
759 }
760
761 /**
762 * @tc.name: SetFrameGravity
763 * @tc.desc: SetFrameGravity Test
764 * @tc.type: FUNC
765 */
766 HWTEST_F(SceneSessionTest4, SetFrameGravity, Function | SmallTest | Level2)
767 {
768 SessionInfo info;
769 info.abilityName_ = "SetFrameGravity";
770 info.bundleName_ = "SetFrameGravity";
771 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
772 EXPECT_NE(session, nullptr);
773
774 struct RSSurfaceNodeConfig config;
775 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
776 session->surfaceNode_ = surfaceNode;
777 ASSERT_EQ(true, session->SetFrameGravity(Gravity::RESIZE));
778 session->surfaceNode_ = nullptr;
779 ASSERT_EQ(false, session->SetFrameGravity(Gravity::TOP_LEFT));
780 }
781 }
782 }
783 }