1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <parameters.h>
18
19 #include "ability_context_impl.h"
20 #include "display_info.h"
21 #include "mock_session.h"
22 #include "mock_uicontent.h"
23 #include "mock_window_adapter.h"
24 #include "scene_board_judgement.h"
25 #include "session/host/include/scene_session.h"
26 #include "singleton_mocker.h"
27 #include "window_scene_session_impl.h"
28 #include "window_session_impl.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
36
37 class MockWindowChangeListener : public IWindowChangeListener {
38 public:
39 MOCK_METHOD3(OnSizeChange,
40 void(Rect rect, WindowSizeChangeReason reason, const std::shared_ptr<RSTransaction>& rsTransaction));
41 };
42
43 class MockWindowLifeCycleListener : public IWindowLifeCycle {
44 public:
45 MOCK_METHOD0(AfterForeground, void(void));
46 MOCK_METHOD0(AfterBackground, void(void));
47 MOCK_METHOD0(AfterFocused, void(void));
48 MOCK_METHOD0(AfterUnfocused, void(void));
49 MOCK_METHOD1(ForegroundFailed, void(int32_t));
50 MOCK_METHOD0(AfterActive, void(void));
51 MOCK_METHOD0(AfterInactive, void(void));
52 MOCK_METHOD0(AfterResumed, void(void));
53 MOCK_METHOD0(AfterPaused, void(void));
54 };
55
56 class WindowSceneSessionImplLayoutTest : public testing::Test {
57 public:
58 static void SetUpTestCase();
59 static void TearDownTestCase();
60 void SetUp() override;
61 void TearDown() override;
62
63 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
64 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
65
66 private:
67 RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
68 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
69 static constexpr uint32_t WAIT_SERVERAL_FRAMES = 36000;
70 };
71
SetUpTestCase()72 void WindowSceneSessionImplLayoutTest::SetUpTestCase() {}
73
TearDownTestCase()74 void WindowSceneSessionImplLayoutTest::TearDownTestCase() {}
75
SetUp()76 void WindowSceneSessionImplLayoutTest::SetUp()
77 {
78 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
79 }
80
TearDown()81 void WindowSceneSessionImplLayoutTest::TearDown()
82 {
83 usleep(WAIT_SYNC_IN_NS);
84 abilityContext_ = nullptr;
85 }
86
CreateRSSurfaceNode()87 RSSurfaceNode::SharedPtr WindowSceneSessionImplLayoutTest::CreateRSSurfaceNode()
88 {
89 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
90 rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
91 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
92 return surfaceNode;
93 }
94
95 namespace {
96
97 /**
98 * @tc.name: SetAspectRatio01
99 * @tc.desc: SetAspectRatio test
100 * @tc.type: FUNC
101 */
102 HWTEST_F(WindowSceneSessionImplLayoutTest, SetAspectRatio01, TestSize.Level1)
103 {
104 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
105 option->SetWindowName("SetAspectRatio01");
106 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
107 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
108 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetAspectRatio(0.1));
109 }
110
111 /**
112 * @tc.name: SetAspectRatio02
113 * @tc.desc: SetAspectRatio test
114 * @tc.type: FUNC
115 */
116 HWTEST_F(WindowSceneSessionImplLayoutTest, SetAspectRatio02, TestSize.Level0)
117 {
118 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
119 option->SetWindowName("SetAspectRatio02");
120 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
121 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
122 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetAspectRatio(0.1));
123
124 window->property_->SetPersistentId(1);
125 window->property_->SetDisplayId(0);
126 WindowLimits windowLimits = { 3000, 3000, 2000, 2000, 2.0, 2.0 };
127 window->property_->SetWindowLimits(windowLimits);
128 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
129 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
130 window->hostSession_ = session;
131 session->GetSessionProperty()->SetWindowLimits(windowLimits);
132 const float ratio = 1.2;
133 ASSERT_EQ(WMError::WM_OK, window->SetAspectRatio(ratio));
134 ASSERT_EQ(ratio, session->GetAspectRatio());
135 }
136
137 /**
138 * @tc.name: SetAspectRatio03
139 * @tc.desc: SetAspectRatio
140 * @tc.type: FUNC
141 */
142 HWTEST_F(WindowSceneSessionImplLayoutTest, SetAspectRatio03, TestSize.Level1)
143 {
144 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
145 option->SetWindowName("SetAspectRatio03");
146 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
147 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
148 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
149 windowSceneSessionImpl->hostSession_ = session;
150 auto ret = windowSceneSessionImpl->SetAspectRatio(MathHelper::INF);
151 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
152 windowSceneSessionImpl->property_->SetPersistentId(1);
153 ret = windowSceneSessionImpl->SetAspectRatio(MathHelper::INF);
154 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
155 ret = windowSceneSessionImpl->SetAspectRatio(MathHelper::NAG_INF);
156 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
157 ret = windowSceneSessionImpl->SetAspectRatio(std::sqrt(-1.0));
158 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
159 ret = windowSceneSessionImpl->SetAspectRatio(0.0f);
160 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
161 ret = windowSceneSessionImpl->SetAspectRatio(1.0f);
162 EXPECT_EQ(WMError::WM_OK, ret);
163 }
164
165 /**
166 * @tc.name: ResetAspectRatio01
167 * @tc.desc: ResetAspectRatio test GetAvoidAreaByType
168 * @tc.type: FUNC
169 */
170 HWTEST_F(WindowSceneSessionImplLayoutTest, ResetAspectRatio01, TestSize.Level1)
171 {
172 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
173 option->SetWindowName("ResetAspectRatio01");
174 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
175 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
176 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
177 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
178 window->hostSession_ = session;
179 ASSERT_EQ(WMError::WM_OK, window->ResetAspectRatio());
180 ASSERT_EQ(0, session->GetAspectRatio());
181 }
182
183 /**
184 * @tc.name: ResetAspectRatio02
185 * @tc.desc: ResetAspectRatio
186 * @tc.type: FUNC
187 */
188 HWTEST_F(WindowSceneSessionImplLayoutTest, ResetAspectRatio02, TestSize.Level1)
189 {
190 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
191 option->SetWindowName("ResetAspectRatio02");
192 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
193 windowSceneSessionImpl->hostSession_ = nullptr;
194 auto ret = windowSceneSessionImpl->ResetAspectRatio();
195 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
196 windowSceneSessionImpl->property_->SetPersistentId(1);
197 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
198 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
199 windowSceneSessionImpl->hostSession_ = session;
200 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
201 ret = windowSceneSessionImpl->ResetAspectRatio();
202 EXPECT_EQ(WMError::WM_OK, ret);
203 }
204
205 /**
206 * @tc.name: SetWindowLimits01
207 * @tc.desc: SetWindowLimits
208 * @tc.type: FUNC
209 */
210 HWTEST_F(WindowSceneSessionImplLayoutTest, SetWindowLimits01, TestSize.Level0)
211 {
212 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
213 option->SetWindowName("SetWindowLimits01");
214 option->SetDisplayId(0);
215
216 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
217
218 window->property_->SetPersistentId(1);
219 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
220 window->state_ = WindowState::STATE_FROZEN;
221 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
222 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
223 window->hostSession_ = session;
224
225 window->useUniqueDensity_ = true;
226 window->virtualPixelRatio_ = 1.9;
227
228 WindowLimits windowLimits = { 2000, 2000, 2000, 2000, 0.0f, 0.0f };
229 EXPECT_EQ(WMError::WM_OK, window->SetWindowLimits(windowLimits, false));
230 WindowLimits windowSizeLimits = window->property_->GetWindowLimits();
231 EXPECT_EQ(windowSizeLimits.maxWidth_, 2000);
232 EXPECT_EQ(windowSizeLimits.maxHeight_, 2000);
233 EXPECT_EQ(windowSizeLimits.minWidth_, 2000);
234 EXPECT_EQ(windowSizeLimits.minHeight_, 2000);
235
236 windowLimits = { 2000, 2000, 100, 100, 0.0f, 0.0f };
237 EXPECT_EQ(WMError::WM_OK, window->SetWindowLimits(windowLimits, false));
238 windowSizeLimits = window->property_->GetWindowLimits();
239 EXPECT_EQ(windowSizeLimits.maxWidth_, 2000);
240 EXPECT_EQ(windowSizeLimits.maxHeight_, 2000);
241 EXPECT_NE(windowSizeLimits.minWidth_, 100);
242 EXPECT_NE(windowSizeLimits.minHeight_, 100);
243
244 windowLimits = { 10000, 10000, 30, 30, 0.0f, 0.0f };
245 EXPECT_EQ(WMError::WM_OK, window->SetWindowLimits(windowLimits, false));
246 windowSizeLimits = window->property_->GetWindowLimits();
247 EXPECT_NE(windowSizeLimits.maxWidth_, 10000);
248 EXPECT_NE(windowSizeLimits.maxHeight_, 10000);
249 EXPECT_NE(windowSizeLimits.minWidth_, 30);
250 EXPECT_NE(windowSizeLimits.minHeight_, 30);
251 }
252
253 /**
254 * @tc.name: SetWindowLimits06
255 * @tc.desc: SetWindowLimits
256 * @tc.type: FUNC
257 */
258 HWTEST_F(WindowSceneSessionImplLayoutTest, SetWindowLimits06, TestSize.Level0)
259 {
260 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
261 option->SetWindowName("SetWindowLimits06");
262 option->SetDisplayId(0);
263
264 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
265
266 window->property_->SetPersistentId(1);
267 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
268 window->state_ = WindowState::STATE_FROZEN;
269 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
270 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
271 window->hostSession_ = session;
272
273 window->useUniqueDensity_ = true;
274 window->virtualPixelRatio_ = 1.9;
275
276 WindowLimits windowLimits = { 2000, 2000, 2000, 2000, 0.0f, 0.0f };
277 EXPECT_EQ(WMError::WM_OK, window->SetWindowLimits(windowLimits, true));
278 WindowLimits windowSizeLimits = window->property_->GetWindowLimits();
279 EXPECT_EQ(windowSizeLimits.maxWidth_, 2000);
280 EXPECT_EQ(windowSizeLimits.maxHeight_, 2000);
281 EXPECT_EQ(windowSizeLimits.minWidth_, 2000);
282 EXPECT_EQ(windowSizeLimits.minHeight_, 2000);
283
284 windowLimits = { 2000, 2000, 100, 100, 0.0f, 0.0f };
285 EXPECT_EQ(WMError::WM_OK, window->SetWindowLimits(windowLimits, true));
286 windowSizeLimits = window->property_->GetWindowLimits();
287 EXPECT_EQ(windowSizeLimits.maxWidth_, 2000);
288 EXPECT_EQ(windowSizeLimits.maxHeight_, 2000);
289 EXPECT_NE(windowSizeLimits.minWidth_, 100);
290 EXPECT_NE(windowSizeLimits.minHeight_, 100);
291
292 windowLimits = { 2000, 2000, 100, 100, 0.0f, 0.0f };
293 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
294 EXPECT_EQ(WMError::WM_OK, window->SetWindowLimits(windowLimits, true));
295 windowSizeLimits = window->property_->GetWindowLimits();
296 EXPECT_EQ(windowSizeLimits.maxWidth_, 2000);
297 EXPECT_EQ(windowSizeLimits.maxHeight_, 2000);
298 EXPECT_EQ(windowSizeLimits.minWidth_, 100);
299 EXPECT_EQ(windowSizeLimits.minHeight_, 100);
300
301 windowLimits = { 10000, 10000, 30, 30, 0.0f, 0.0f };
302 EXPECT_EQ(WMError::WM_OK, window->SetWindowLimits(windowLimits, true));
303 windowSizeLimits = window->property_->GetWindowLimits();
304 EXPECT_NE(windowSizeLimits.maxWidth_, 10000);
305 EXPECT_NE(windowSizeLimits.maxHeight_, 10000);
306 EXPECT_NE(windowSizeLimits.minWidth_, 30);
307 EXPECT_NE(windowSizeLimits.minHeight_, 30);
308 }
309
310 /**
311 * @tc.name: SetWindowLimits02
312 * @tc.desc: SetWindowLimits
313 * @tc.type: FUNC
314 */
315 HWTEST_F(WindowSceneSessionImplLayoutTest, SetWindowLimits02, TestSize.Level1)
316 {
317 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
318 option->SetWindowName("SetWindowLimits02");
319 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
320 WindowLimits windowLimits = { 1000, 1000, 1000, 1000, 0.0f, 0.0f };
321
322 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_END);
323 auto ret = windowSceneSessionImpl->SetWindowLimits(windowLimits, false);
324 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
325 ret = windowSceneSessionImpl->SetWindowLimits(windowLimits, true);
326 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
327 }
328
329 /**
330 * @tc.name: SetWindowLimits03
331 * @tc.desc: SetWindowLimits
332 * @tc.type: FUNC
333 */
334 HWTEST_F(WindowSceneSessionImplLayoutTest, SetWindowLimits03, TestSize.Level1)
335 {
336 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
337 option->SetWindowName("SetWindowLimits03");
338 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
339 WindowLimits windowLimits = { 1000, 1000, 1000, 1000, 0.0f, 0.0f };
340 windowSceneSessionImpl->property_->SetPersistentId(1);
341 windowSceneSessionImpl->property_->SetDisplayId(0);
342 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
343 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
344 windowSceneSessionImpl->hostSession_ = session;
345 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
346 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
347 auto ret = windowSceneSessionImpl->SetWindowLimits(windowLimits, false);
348 EXPECT_EQ(WMError::WM_OK, ret);
349 ret = windowSceneSessionImpl->SetWindowLimits(windowLimits, true);
350 EXPECT_EQ(WMError::WM_OK, ret);
351 }
352
353 /**
354 * @tc.name: SetWindowLimits04
355 * @tc.desc: SetWindowLimits
356 * @tc.type: FUNC
357 */
358 HWTEST_F(WindowSceneSessionImplLayoutTest, SetWindowLimits04, TestSize.Level1)
359 {
360 sptr<WindowOption> subWindow = sptr<WindowOption>::MakeSptr();
361 subWindow->SetWindowName("SetWindowLimits04");
362 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(subWindow);
363 WindowLimits windowLimits = { 1000, 1000, 1000, 1000, 0.0f, 0.0f };
364 windowSceneSessionImpl->SetWindowLimits(windowLimits, false);
365 windowSceneSessionImpl->property_->SetPersistentId(1004);
366 windowSceneSessionImpl->property_->SetDisplayId(0);
367 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
368 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
369 windowSceneSessionImpl->hostSession_ = session;
370 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
371 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_LAUNCHING);
372 auto ret = windowSceneSessionImpl->SetWindowLimits(windowLimits, false);
373 EXPECT_EQ(WMError::WM_OK, ret);
374 ret = windowSceneSessionImpl->SetWindowLimits(windowLimits, true);
375 EXPECT_EQ(WMError::WM_OK, ret);
376 }
377
378 /**
379 * @tc.name: SetWindowLimits05
380 * @tc.desc: SetWindowLimits
381 * @tc.type: FUNC
382 */
383 HWTEST_F(WindowSceneSessionImplLayoutTest, SetWindowLimits05, TestSize.Level1)
384 {
385 sptr<WindowOption> subWindow = sptr<WindowOption>::MakeSptr();
386 subWindow->SetWindowName("SetWindowLimits05");
387 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(subWindow);
388 WindowLimits windowLimits = { 1000, 1000, 1000, 1000, 0.0f, 0.0f };
389 windowSceneSessionImpl->property_->SetPersistentId(1005);
390 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
391 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(sessionInfo);
392 windowSceneSessionImpl->hostSession_ = subSession;
393 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_END);
394 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, windowSceneSessionImpl->SetWindowLimits(windowLimits, false));
395 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, windowSceneSessionImpl->SetWindowLimits(windowLimits, true));
396
397 windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
398 EXPECT_EQ(WMError::WM_OK, windowSceneSessionImpl->SetWindowLimits(windowLimits, false));
399 EXPECT_EQ(WMError::WM_OK, windowSceneSessionImpl->SetWindowLimits(windowLimits, true));
400
401 windowSceneSessionImpl->property_->SetDragEnabled(false);
402 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, windowSceneSessionImpl->SetWindowLimits(windowLimits, false));
403 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, windowSceneSessionImpl->SetWindowLimits(windowLimits, true));
404 }
405
406 /**
407 * @tc.name: CalculateNewLimitsByRatio01
408 * @tc.desc: CalculateNewLimitsByRatio
409 * @tc.type: FUNC
410 */
411 HWTEST_F(WindowSceneSessionImplLayoutTest, CalculateNewLimitsByRatio01, TestSize.Level1)
412 {
413 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
414 option->SetWindowName("CalculateNewLimitsByRatio01");
415 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
416
417 WindowLimits newLimits = { 0, 0, 0, 0, 0.0, 0.0 };
418 WindowLimits customizedLimits = { 3, 3, 3, 3, 0.0, 0.0 };
419 windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
420 newLimits = { 500, 500, 500, 500, 0.0, 0.0 };
421 customizedLimits = { 3, 3, 3, 3, 2.0, 2.0 };
422 windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
423 customizedLimits = { 3, 3, 3, 3, 1.0, 1.0 };
424 windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
425 windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_END);
426 auto ret = windowSceneSessionImpl->UpdateAnimationFlagProperty(true);
427 EXPECT_EQ(WMError::WM_OK, ret);
428 }
429
430 /**
431 * @tc.name: CalculateNewLimitsByRatio02
432 * @tc.desc: CalculateNewLimitsByRatio
433 * @tc.type: FUNC
434 */
435 HWTEST_F(WindowSceneSessionImplLayoutTest, CalculateNewLimitsByRatio02, TestSize.Level1)
436 {
437 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
438 option->SetWindowName("CalculateNewLimitsByRatio02");
439 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
440
441 WindowLimits newLimits = { 0, 0, 0, 0, 0.0, 0.0 };
442 WindowLimits customizedLimits = { 3, 3, 3, 3, 0.0, 0.0 };
443 windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
444 newLimits = { 500, 500, 500, 500, 0.0, 0.0 };
445 customizedLimits = { 3, 3, 3, 3, 2.0, 2.0 };
446 windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
447 customizedLimits = { 3, 3, 3, 3, 1.0, 1.0 };
448 windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
449 windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
450 auto ret = windowSceneSessionImpl->UpdateAnimationFlagProperty(true);
451 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
452 }
453
454 /**
455 * @tc.name: MoveToAsync01
456 * @tc.desc: MoveToAsync
457 * @tc.type: FUNC
458 */
459 HWTEST_F(WindowSceneSessionImplLayoutTest, MoveToAsync01, TestSize.Level0)
460 {
461 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
462 option->SetWindowName("MoveToAsync01");
463 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
464 option->SetWindowType(WindowType::WINDOW_TYPE_PIP);
465 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
466 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MoveToAsync(10, 10));
467
468 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
469 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
470 window->hostSession_ = session;
471 window->property_->SetPersistentId(1);
472 ASSERT_EQ(WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS, window->MoveToAsync(10, 10));
473 }
474
475 /**
476 * @tc.name: MoveToAsync02
477 * @tc.desc: MoveToAsync
478 * @tc.type: FUNC
479 */
480 HWTEST_F(WindowSceneSessionImplLayoutTest, MoveToAsync02, TestSize.Level1)
481 {
482 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
483 option->SetWindowName("MoveToAsync02");
484 option->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
485 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
486 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
487 window->property_->SetPersistentId(10001);
488 Rect rect;
489 WMError ret;
490 ret = window->Create(abilityContext_, nullptr);
491 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
492 EXPECT_EQ(WMError::WM_OK, ret);
493 ret = window->Show();
494 EXPECT_EQ(WMError::WM_OK, ret);
495 window->state_ = WindowState::STATE_SHOWN;
496 ret = window->MoveToAsync(500, 500);
497 EXPECT_EQ(WMError::WM_OK, ret);
498 rect = window->property_->GetWindowRect();
499 EXPECT_EQ(500, rect.posX_);
500 EXPECT_EQ(500, rect.posY_);
501 window->state_ = WindowState::STATE_HIDDEN;
502 ret = window->MoveToAsync(20000, 20000);
503 usleep(WAIT_SERVERAL_FRAMES);
504 EXPECT_EQ(WMError::WM_OK, ret);
505 rect = window->property_->GetWindowRect();
506 EXPECT_EQ(20000, rect.posX_);
507 EXPECT_EQ(20000, rect.posY_);
508 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
509 } else {
510 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
511 }
512 }
513
514 /**
515 * @tc.name: ResizeAsync01
516 * @tc.desc: ResizeAsync
517 * @tc.type: FUNC
518 */
519 HWTEST_F(WindowSceneSessionImplLayoutTest, ResizeAsync01, TestSize.Level0)
520 {
521 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
522 option->SetWindowName("ResizeAsync01");
523 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
524 option->SetWindowType(WindowType::WINDOW_TYPE_PIP);
525 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
526 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
527 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
528 window->hostSession_ = session;
529 window->property_->SetPersistentId(1);
530 ASSERT_EQ(WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS, window->ResizeAsync(500, 500));
531 }
532
533 /**
534 * @tc.name: ResizeAsync02
535 * @tc.desc: ResizeAsync
536 * @tc.type: FUNC
537 */
538 HWTEST_F(WindowSceneSessionImplLayoutTest, ResizeAsync02, TestSize.Level1)
539 {
540 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
541 option->SetWindowName("ResizeAsync02");
542 option->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
543 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
544 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
545 window->property_->SetPersistentId(10012);
546 Rect rect;
547 WMError ret;
548 ret = window->Create(abilityContext_, nullptr);
549 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
550 EXPECT_EQ(WMError::WM_OK, ret);
551 ret = window->Show();
552 EXPECT_EQ(WMError::WM_OK, ret);
553 WindowLimits windowLimits;
554 ret = window->GetWindowLimits(windowLimits);
555 EXPECT_EQ(WMError::WM_OK, ret);
556 window->state_ = WindowState::STATE_SHOWN;
557 ret = window->ResizeAsync(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
558 EXPECT_EQ(WMError::WM_OK, ret);
559 rect = window->property_->GetWindowRect();
560 EXPECT_EQ(windowLimits.maxWidth_ - 100, rect.width_);
561 EXPECT_EQ(windowLimits.maxHeight_ - 100, rect.height_);
562 window->state_ = WindowState::STATE_HIDDEN;
563 ret = window->ResizeAsync(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
564 EXPECT_EQ(WMError::WM_OK, ret);
565 usleep(WAIT_SERVERAL_FRAMES);
566 rect = window->property_->GetWindowRect();
567 EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
568 EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
569 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
570 } else {
571 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
572 }
573 }
574
575 /**
576 * @tc.name: MoveTo01
577 * @tc.desc: MoveTo
578 * @tc.type: FUNC
579 */
580 HWTEST_F(WindowSceneSessionImplLayoutTest, MoveTo01, TestSize.Level1)
581 {
582 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
583 option->SetWindowName("MoveTo01");
584 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
585
586 windowSceneSession->property_->SetPersistentId(1);
587 windowSceneSession->state_ = WindowState::STATE_HIDDEN;
588 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
589 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
590 windowSceneSession->hostSession_ = session;
591 ASSERT_EQ(WMError::WM_OK, windowSceneSession->MoveTo(2, 2));
592 }
593
594 /**
595 * @tc.name: MoveTo02
596 * @tc.desc: MoveTo
597 * @tc.type: FUNC
598 */
599 HWTEST_F(WindowSceneSessionImplLayoutTest, MoveTo02, TestSize.Level1)
600 {
601 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
602 subOption->SetWindowName("MoveTo02SubWindow");
603 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
604 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
605 subWindow->property_->SetPersistentId(1001);
606 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
607 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
608 subWindow->hostSession_ = subSession;
609 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(2, 2));
610
611 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
612 option->SetWindowName("MoveTo02");
613 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
614 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
615 window->property_->SetPersistentId(1);
616 SessionInfo sessionInfo = { "CreateTestBundle2", "CreateTestModule2", "CreateTestAbility2" };
617 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
618 window->hostSession_ = session;
619 window->state_ = WindowState::STATE_SHOWN;
620 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
621 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(3, 3));
622 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
623 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(3, 3));
624 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(3, 4));
625 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 4));
626 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
627 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 4));
628 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 5));
629 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(5, 5));
630 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
631 }
632
633 /**
634 * @tc.name: MoveTo03
635 * @tc.desc: MoveTo
636 * @tc.type: FUNC
637 */
638 HWTEST_F(WindowSceneSessionImplLayoutTest, MoveTo03, TestSize.Level1)
639 {
640 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
641 subOption->SetWindowName("MoveTo01SubWindow");
642 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
643 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
644 subWindow->property_->SetPersistentId(1001);
645 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
646 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
647 subWindow->hostSession_ = subSession;
648 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(2, 2));
649
650 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
651 option->SetWindowName("MoveTo02");
652 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
653 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
654 window->property_->SetPersistentId(1);
655 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
656 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
657 window->hostSession_ = session;
658 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(
659 window->GetWindowName(), std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
660 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(3, 3));
661 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
662 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 3));
663 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 4));
664 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
665 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(5, 4));
666 ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(5, 4));
667 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
668 }
669
670 /**
671 * @tc.name: UpdateWindowModeForUITest01
672 * @tc.desc: UpdateWindowModeForUITest
673 * @tc.type: FUNC
674 */
675 HWTEST_F(WindowSceneSessionImplLayoutTest, UpdateWindowModeForUITest01, TestSize.Level1)
676 {
677 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
678 option->SetWindowName("UpdateWindowModeForUITest01");
679 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
680 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
681 const int32_t windowId = 1;
682 window->property_->SetPersistentId(windowId);
683 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
684 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
685 window->hostSession_ = session;
686
687 WMError res = window->UpdateWindowModeForUITest(static_cast<int32_t>(WindowMode::WINDOW_MODE_UNDEFINED));
688 EXPECT_EQ(WMError::WM_DO_NOTHING, res);
689 res = window->UpdateWindowModeForUITest(static_cast<int32_t>(WindowMode::WINDOW_MODE_FULLSCREEN));
690 EXPECT_EQ(WMError::WM_OK, res);
691 res = window->UpdateWindowModeForUITest(static_cast<int32_t>(WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
692 EXPECT_EQ(WMError::WM_OK, res);
693 res = window->UpdateWindowModeForUITest(static_cast<int32_t>(WindowMode::WINDOW_MODE_SPLIT_SECONDARY));
694 EXPECT_EQ(WMError::WM_OK, res);
695 res = window->UpdateWindowModeForUITest(static_cast<int32_t>(WindowMode::WINDOW_MODE_FLOATING));
696 EXPECT_EQ(WMError::WM_OK, res);
697 }
698
699 /**
700 * @tc.name: GetAppHookWindowInfoFromServer
701 * @tc.desc: GetAppHookWindowInfoFromServer
702 * @tc.type: FUNC
703 */
704 HWTEST_F(WindowSceneSessionImplLayoutTest, GetAppHookWindowInfoFromServer, TestSize.Level1)
705 {
706 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
707 option->SetWindowName("GetAppHookWindowInfoFromServer");
708 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
709 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
710 const int32_t windowId = 2025;
711 window->property_->SetPersistentId(windowId);
712
713 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
714 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
715 window->hostSession_ = session;
716 HookWindowInfo hookWindowInfo;
717 WMError res = window->GetAppHookWindowInfoFromServer(hookWindowInfo);
718 EXPECT_NE(res, WMError::WM_ERROR_INVALID_WINDOW);
719 }
720
721 /**
722 * @tc.name: NotifyAppHookWindowInfoUpdated
723 * @tc.desc: NotifyAppHookWindowInfoUpdated
724 * @tc.type: FUNC
725 */
726 HWTEST_F(WindowSceneSessionImplLayoutTest, NotifyAppHookWindowInfoUpdated, TestSize.Level1)
727 {
728 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
729 option->SetWindowName("NotifyAppHookWindowInfoUpdated");
730 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
731 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
732 const int32_t windowId = 2025;
733 window->property_->SetPersistentId(windowId);
734
735 // Case 1: GetAppHookWindowInfoFromServer failed
736 window->hostSession_ = nullptr;
737 WSError res = window->NotifyAppHookWindowInfoUpdated();
738 EXPECT_EQ(res, WSError::WS_DO_NOTHING);
739
740 // Case 2: success
741 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
742 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
743 window->hostSession_ = session;
744 res = window->NotifyAppHookWindowInfoUpdated();
745 EXPECT_EQ(res, WSError::WS_OK);
746
747 // Case 3: not mainWindow
748 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
749 res = window->NotifyAppHookWindowInfoUpdated();
750 EXPECT_EQ(res, WSError::WS_DO_NOTHING);
751 }
752
753 /**
754 * @tc.name: GetGlobalScaledRect
755 * @tc.desc: GetGlobalScaledRect
756 * @tc.type: FUNC
757 */
758 HWTEST_F(WindowSceneSessionImplLayoutTest, GetGlobalScaledRect, TestSize.Level1)
759 {
760 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
761 option->SetWindowName("GetGlobalScaledRect");
762 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
763 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
764 const int32_t windowId = 2025;
765 window->property_->SetPersistentId(windowId);
766 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
767 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
768 window->hostSession_ = session;
769 HookWindowInfo hookWindowInfo;
770 hookWindowInfo.enableHookWindow = true;
771 hookWindowInfo.widthHookRatio = 0.5f;
772 window->SetAppHookWindowInfo(hookWindowInfo);
773 Rect globalScaledRect = { 0, 0, 800, 800 };
774 WMError res = window->GetGlobalScaledRect(globalScaledRect);
775 EXPECT_EQ(res, WMError::WM_OK);
776 EXPECT_NE(globalScaledRect.width_, 800);
777 }
778 } // namespace
779 } // namespace Rosen
780 } // namespace OHOS
781