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