1 /*
2 * Copyright (c) 2021-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 // gtest
17 #include <gtest/gtest.h>
18 #include "ability_context_impl.h"
19 #include "common_test_utils.h"
20 #include "mock_session.h"
21 #include "session/host/include/scene_session.h"
22 #include "window_test_utils.h"
23 #include "window_adapter.h"
24 #include "window_scene_session_impl.h"
25 #include "wm_common.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 using Utils = WindowTestUtils;
33 class WindowLayoutTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 private:
40 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
41 static constexpr uint32_t WAIT_SERVERAL_FRAMES = 70000;
42 };
43
44
SetUpTestCase()45 void WindowLayoutTest::SetUpTestCase()
46 {
47 }
48
TearDownTestCase()49 void WindowLayoutTest::TearDownTestCase()
50 {
51 }
52
SetUp()53 void WindowLayoutTest::SetUp()
54 {
55 }
56
TearDown()57 void WindowLayoutTest::TearDown()
58 {
59 }
60
61
62 namespace {
63
64 /**
65 * @tc.name: moveWindowTo01
66 * @tc.desc: test moveWindowTo for ALN/PC with windowMode: 102, windowType: 2107
67 * @tc.type: FUNC
68 */
69 HWTEST_F(WindowLayoutTest, moveWindowTo01, Function | MediumTest | Level3)
70 {
71 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
72 option->SetWindowName("moveWindowTo01");
73 option->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
74 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
75
76 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
77
78 window->property_->SetPersistentId(10001);
79
80 Rect rect;
81 WMError ret;
82 ret = window->Create(abilityContext_, nullptr);
83 EXPECT_EQ(WMError::WM_OK, ret);
84
85 ret = window->Show();
86 EXPECT_EQ(WMError::WM_OK, ret);
87
88 ret = window->MoveTo(-500, -500);
89 usleep(WAIT_SERVERAL_FRAMES);
90 EXPECT_EQ(WMError::WM_OK, ret);
91 rect = window->property_->GetWindowRect();
92 EXPECT_EQ(-500, rect.posX_);
93 EXPECT_EQ(-500, rect.posY_);
94
95 ret = window->MoveTo(0, 0);
96 usleep(WAIT_SERVERAL_FRAMES);
97 EXPECT_EQ(WMError::WM_OK, ret);
98 rect = window->property_->GetWindowRect();
99 EXPECT_EQ(0, rect.posX_);
100 EXPECT_EQ(0, rect.posY_);
101
102 ret = window->MoveTo(500, 500);
103 usleep(WAIT_SERVERAL_FRAMES);
104 EXPECT_EQ(WMError::WM_OK, ret);
105 rect = window->property_->GetWindowRect();
106 EXPECT_EQ(500, rect.posX_);
107 EXPECT_EQ(500, rect.posY_);
108
109 ret = window->MoveTo(20000, 20000);
110 usleep(WAIT_SERVERAL_FRAMES);
111 EXPECT_EQ(WMError::WM_OK, ret);
112 rect = window->property_->GetWindowRect();
113 EXPECT_EQ(20000, rect.posX_);
114 EXPECT_EQ(20000, rect.posY_);
115 }
116
117 /**
118 * @tc.name: moveWindowTo02
119 * @tc.desc: test moveWindowTo for ALN with windowMode: 102, windowType: 1001
120 * @tc.type: FUNC
121 */
122 HWTEST_F(WindowLayoutTest, moveWindowTo02, Function | MediumTest | Level3)
123 {
124 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
125 option->SetWindowName("moveWindowTo02");
126 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
127 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
128
129 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
130
131 SessionInfo sessionInfo = { "bundleName_moveWindowTo02",
132 "moduleName_moveWindowTo02", "abilityName_moveWindowTo02" };
133 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
134
135 Rect rectOld;
136 Rect rectNow;
137 WMError ret;
138 ret = window->Create(abilityContext_, sceneSession);
139 EXPECT_EQ(WMError::WM_OK, ret);
140 ret = window->Show();
141 EXPECT_EQ(WMError::WM_OK, ret);
142 window->property_->SetPersistentId(10002);
143
144 rectOld = window->property_->GetWindowRect();
145 ret = window->MoveTo(-500, -500);
146 usleep(WAIT_SERVERAL_FRAMES);
147 EXPECT_EQ(WMError::WM_OK, ret);
148 rectNow = window->property_->GetWindowRect();
149 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
150 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
151
152 rectOld = window->property_->GetWindowRect();
153 ret = window->MoveTo(0, 0);
154 usleep(WAIT_SERVERAL_FRAMES);
155 EXPECT_EQ(WMError::WM_OK, ret);
156 rectNow = window->property_->GetWindowRect();
157 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
158 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
159
160 rectOld = window->property_->GetWindowRect();
161 ret = window->MoveTo(500, 500);
162 usleep(WAIT_SERVERAL_FRAMES);
163 EXPECT_EQ(WMError::WM_OK, ret);
164 rectNow = window->property_->GetWindowRect();
165 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
166 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
167 }
168
169 /**
170 * @tc.name: moveWindowTo03
171 * @tc.desc: test moveWindowTo for ALN with windowMode: 1, windowType: 1
172 * @tc.type: FUNC
173 */
174 HWTEST_F(WindowLayoutTest, moveWindowTo03, Function | MediumTest | Level3)
175 {
176 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
177 option->SetWindowName("moveWindowTo03");
178 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
179 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
180
181 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
182
183 window->property_->SetPersistentId(10003);
184
185 SessionInfo sessionInfo = { "bundleName_moveWindowTo03",
186 "moduleName_moveWindowTo03", "abilityName_moveWindowTo03" };
187 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
188
189 Rect rectOld;
190 Rect rectNow;
191 WMError ret;
192 ret = window->Create(abilityContext_, sceneSession);
193 EXPECT_EQ(WMError::WM_OK, ret);
194 ret = window->Show();
195 EXPECT_EQ(WMError::WM_OK, ret);
196
197 rectOld = window->property_->GetWindowRect();
198 ret = window->MoveTo(-500, -500);
199 usleep(WAIT_SERVERAL_FRAMES);
200 EXPECT_EQ(WMError::WM_OK, ret);
201 rectNow = window->property_->GetWindowRect();
202 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
203 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
204
205 rectOld = window->property_->GetWindowRect();
206 ret = window->MoveTo(0, 0);
207 usleep(WAIT_SERVERAL_FRAMES);
208 EXPECT_EQ(WMError::WM_OK, ret);
209 rectNow = window->property_->GetWindowRect();
210 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
211 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
212
213 rectOld = window->property_->GetWindowRect();
214 ret = window->MoveTo(500, 500);
215 usleep(WAIT_SERVERAL_FRAMES);
216 EXPECT_EQ(WMError::WM_OK, ret);
217 rectNow = window->property_->GetWindowRect();
218 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
219 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
220
221 rectOld = window->property_->GetWindowRect();
222 ret = window->MoveTo(20000, 20000);
223 usleep(WAIT_SERVERAL_FRAMES);
224 EXPECT_EQ(WMError::WM_OK, ret);
225 rectNow = window->property_->GetWindowRect();
226 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
227 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
228 }
229
230 /**
231 * @tc.name: moveWindowTo04
232 * @tc.desc: test moveWindowTo for ALN with windowMode: 100, windowType: 1
233 * @tc.type: FUNC
234 */
235 HWTEST_F(WindowLayoutTest, moveWindowTo04, Function | MediumTest | Level3)
236 {
237 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
238 option->SetWindowName("moveWindowTo04");
239 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
240 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
241
242 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
243
244 window->property_->SetPersistentId(10004);
245
246 SessionInfo sessionInfo = { "bundleName_moveWindowTo04",
247 "moduleName_moveWindowTo04", "abilityName_moveWindowTo04" };
248 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
249
250 Rect rectOld;
251 Rect rectNow;
252 WMError ret;
253 ret = window->Create(abilityContext_, sceneSession);
254 EXPECT_EQ(WMError::WM_OK, ret);
255 ret = window->Show();
256 EXPECT_EQ(WMError::WM_OK, ret);
257
258 rectOld = window->property_->GetWindowRect();
259 ret = window->MoveTo(-500, -500);
260 usleep(WAIT_SERVERAL_FRAMES);
261 EXPECT_EQ(WMError::WM_OK, ret);
262 rectNow = window->property_->GetWindowRect();
263 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
264 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
265
266 rectOld = window->property_->GetWindowRect();
267 ret = window->MoveTo(0, 0);
268 usleep(WAIT_SERVERAL_FRAMES);
269 EXPECT_EQ(WMError::WM_OK, ret);
270 rectNow = window->property_->GetWindowRect();
271 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
272 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
273
274 rectOld = window->property_->GetWindowRect();
275 ret = window->MoveTo(500, 500);
276 usleep(WAIT_SERVERAL_FRAMES);
277 EXPECT_EQ(WMError::WM_OK, ret);
278 rectNow = window->property_->GetWindowRect();
279 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
280 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
281
282 rectOld = window->property_->GetWindowRect();
283 ret = window->MoveTo(20000, 20000);
284 usleep(WAIT_SERVERAL_FRAMES);
285 EXPECT_EQ(WMError::WM_OK, ret);
286 rectNow = window->property_->GetWindowRect();
287 EXPECT_EQ(rectOld.posX_, rectNow.posX_);
288 EXPECT_EQ(rectOld.posY_, rectNow.posY_);
289 }
290
291 /**
292 * @tc.name: resize01
293 * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2107
294 * @tc.type: FUNC
295 */
296 HWTEST_F(WindowLayoutTest, resize01, Function | MediumTest | Level3)
297 {
298 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
299 option->SetWindowName("resize01");
300 option->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
301 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
302
303 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
304
305 Rect rect;
306 WMError ret;
307 ret = window->Create(abilityContext_, nullptr);
308 EXPECT_EQ(WMError::WM_OK, ret);
309 window->property_->SetPersistentId(10008);
310 ret = window->Show();
311 EXPECT_EQ(WMError::WM_OK, ret);
312
313 WindowLimits windowLimits;
314 ret = window->GetWindowLimits(windowLimits);
315 EXPECT_EQ(WMError::WM_OK, ret);
316
317 ret = window->Resize(-500, -500);
318 EXPECT_EQ(WMError::WM_OK, ret);
319 usleep(WAIT_SERVERAL_FRAMES);
320 rect = window->property_->GetWindowRect();
321 EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
322 EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
323
324 ret = window->Resize(500, 500);
325 EXPECT_EQ(WMError::WM_OK, ret);
326 usleep(WAIT_SERVERAL_FRAMES);
327 rect = window->property_->GetWindowRect();
328 EXPECT_EQ(500, rect.width_);
329 EXPECT_EQ(500, rect.height_);
330
331 ret = window->Resize(20000, 20000);
332 EXPECT_EQ(WMError::WM_OK, ret);
333 usleep(WAIT_SERVERAL_FRAMES);
334 rect = window->property_->GetWindowRect();
335 EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
336 EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
337
338 ret = window->Resize(0, 0);
339 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
340 }
341
342 /**
343 * @tc.name: resize02
344 * @tc.desc: test resize for ALN with windowMode: 1, windowType: 1
345 * @tc.type: FUNC
346 */
347 HWTEST_F(WindowLayoutTest, resize02, Function | MediumTest | Level3)
348 {
349 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
350 option->SetWindowName("resize02");
351 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
352 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
353
354 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
355
356 SessionInfo sessionInfo = { "bundleName_resize02", "moduleName_resize02", "abilityName_resize02" };
357 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
358
359 WMError ret;
360 ret = window->Create(abilityContext_, sceneSession);
361 EXPECT_EQ(WMError::WM_OK, ret);
362 window->property_->SetPersistentId(10009);
363 ret = window->Show();
364 EXPECT_EQ(WMError::WM_OK, ret);
365
366 ret = window->Resize(500, 500);
367 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
368
369 ret = window->Resize(20000, 20000);
370 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
371
372 ret = window->Resize(0, 0);
373 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
374 }
375
376 /**
377 * @tc.name: resize03
378 * @tc.desc: test resize for PC with windowMode: 1, windowType: 1
379 * @tc.type: FUNC
380 */
381 HWTEST_F(WindowLayoutTest, resize03, Function | MediumTest | Level3)
382 {
383 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
384 option->SetWindowName("resize03");
385 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
386 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
387
388 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
389
390 SessionInfo sessionInfo = { "bundleName_resize03", "moduleName_resize03", "abilityName_resize03" };
391 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
392
393 WMError ret;
394 ret = window->Create(abilityContext_, sceneSession);
395 EXPECT_EQ(WMError::WM_OK, ret);
396 window->property_->SetPersistentId(100010);
397 ret = window->Show();
398 EXPECT_EQ(WMError::WM_OK, ret);
399
400 ret = window->Resize(500, 500);
401 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
402
403 ret = window->Resize(20000, 20000);
404 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
405
406 ret = window->Resize(0, 0);
407 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
408 }
409
410 /**
411 * @tc.name: resize04
412 * @tc.desc: test resize for ALN/PC with windowMode: 100, windowType: 1
413 * @tc.type: FUNC
414 */
415 HWTEST_F(WindowLayoutTest, resize04, Function | MediumTest | Level3)
416 {
417 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
418 option->SetWindowName("resize04");
419 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
420 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
421
422 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
423
424 SessionInfo sessionInfo = { "bundleName_resize04", "moduleName_resize04", "abilityName_resize04" };
425 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
426
427 WMError ret;
428 ret = window->Create(abilityContext_, sceneSession);
429 EXPECT_EQ(WMError::WM_OK, ret);
430 window->property_->SetPersistentId(100011);
431 ret = window->Show();
432 EXPECT_EQ(WMError::WM_OK, ret);
433
434 ret = window->Resize(500, 500);
435 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
436
437 ret = window->Resize(20000, 20000);
438 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
439
440 ret = window->Resize(0, 0);
441 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
442 }
443
444 /**
445 * @tc.name: resize05
446 * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2107
447 * @tc.type: FUNC
448 */
449 HWTEST_F(WindowLayoutTest, resize05, Function | MediumTest | Level3)
450 {
451 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
452 option->SetWindowName("resize05");
453 option->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
454 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
455
456 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
457
458 Rect rect;
459 WMError ret;
460 ret = window->Create(abilityContext_, nullptr);
461 EXPECT_EQ(WMError::WM_OK, ret);
462 window->property_->SetPersistentId(10012);
463 ret = window->Show();
464 EXPECT_EQ(WMError::WM_OK, ret);
465
466 WindowLimits windowLimits;
467 ret = window->GetWindowLimits(windowLimits);
468
469 ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
470 EXPECT_EQ(WMError::WM_OK, ret);
471 usleep(WAIT_SERVERAL_FRAMES);
472 rect = window->property_->GetWindowRect();
473 EXPECT_EQ(windowLimits.maxWidth_ - 100, rect.width_);
474 EXPECT_EQ(windowLimits.maxHeight_ - 100, rect.height_);
475
476 ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
477 EXPECT_EQ(WMError::WM_OK, ret);
478 usleep(WAIT_SERVERAL_FRAMES);
479 rect = window->property_->GetWindowRect();
480 EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
481 EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
482 }
483
484 /**
485 * @tc.name: resize06
486 * @tc.desc: test resize for ALN with windowMode: 1, windowType: 1
487 * @tc.type: FUNC
488 */
489 HWTEST_F(WindowLayoutTest, resize06, Function | MediumTest | Level3)
490 {
491 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
492 option->SetWindowName("resize06");
493 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
494 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
495
496 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
497
498 SessionInfo sessionInfo = { "bundleName_resize06", "moduleName_resize06", "abilityName_resize06" };
499 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
500
501 WMError ret;
502 ret = window->Create(abilityContext_, sceneSession);
503 EXPECT_EQ(WMError::WM_OK, ret);
504 window->property_->SetPersistentId(100013);
505 ret = window->Show();
506 EXPECT_EQ(WMError::WM_OK, ret);
507
508 WindowLimits windowLimits;
509 ret = window->GetWindowLimits(windowLimits);
510
511 ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
512 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
513
514 ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
515 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
516 }
517
518 /**
519 * @tc.name: resize07
520 * @tc.desc: test resize for PC with windowMode: 1, windowType: 1
521 * @tc.type: FUNC
522 */
523 HWTEST_F(WindowLayoutTest, resize07, Function | MediumTest | Level3)
524 {
525 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
526 option->SetWindowName("resize07");
527 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
528 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
529
530 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
531
532 SessionInfo sessionInfo = { "bundleName_resize07", "moduleName_resize07", "abilityName_resize07" };
533 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
534
535 WMError ret;
536 ret = window->Create(abilityContext_, sceneSession);
537 EXPECT_EQ(WMError::WM_OK, ret);
538 window->property_->SetPersistentId(100014);
539 ret = window->Show();
540 EXPECT_EQ(WMError::WM_OK, ret);
541
542 WindowLimits windowLimits;
543 ret = window->GetWindowLimits(windowLimits);
544
545 ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
546 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
547
548 ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
549 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
550 }
551
552 /**
553 * @tc.name: resize08
554 * @tc.desc: test resize for ALN/PC with windowMode: 100, windowType: 1
555 * @tc.type: FUNC
556 */
557 HWTEST_F(WindowLayoutTest, resize08, Function | MediumTest | Level3)
558 {
559 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
560 option->SetWindowName("resize08");
561 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
562 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
563
564 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
565
566 SessionInfo sessionInfo = { "bundleName_resize08", "moduleName_resize08", "abilityName_resize08" };
567 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
568
569 WMError ret;
570 ret = window->Create(abilityContext_, sceneSession);
571 EXPECT_EQ(WMError::WM_OK, ret);
572 window->property_->SetPersistentId(100015);
573 ret = window->Show();
574 EXPECT_EQ(WMError::WM_OK, ret);
575
576 WindowLimits windowLimits;
577 ret = window->GetWindowLimits(windowLimits);
578
579 ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
580 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
581 ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
582 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
583 }
584
585 /**
586 * @tc.name: SetWindowLimitsDataRoute
587 * @tc.desc: test data route for SetWindowLimits
588 * @tc.type: FUNC
589 */
590 HWTEST_F(WindowLayoutTest, SetWindowLimitsDataRoute, Function | MediumTest | Level3)
591 {
592 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::SetWindowLimitsDataRoute begin ###");
593 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
594 option->SetWindowName("SetWindowLimitsDataRoute");
595 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
596 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
597
598 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
599 windowSceneSessionImpl->property_->SetPersistentId(1);
600 windowSceneSessionImpl->property_->SetDisplayId(0);
601
602 SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
603 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
604
605 windowSceneSessionImpl->hostSession_ = session;
606 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
607
608 WindowLimits windowLimits1 = {4000, 4000, 2000, 2000, 0.0f, 0.0f};
609 WMError ret = windowSceneSessionImpl->SetWindowLimits(windowLimits1, false);
610 EXPECT_EQ(WMError::WM_OK, ret);
611 auto windowProperty = windowSceneSessionImpl->GetProperty();
612 ASSERT_NE(nullptr, windowProperty);
613
614 WindowLimits windowLimits2 = windowProperty->GetWindowLimits();
615 EXPECT_EQ(windowLimits1.maxWidth_, windowLimits2.maxWidth_);
616 EXPECT_EQ(windowLimits1.maxHeight_, windowLimits2.maxHeight_);
617 EXPECT_EQ(windowLimits1.minWidth_, windowLimits2.minWidth_);
618 EXPECT_EQ(windowLimits1.minHeight_, windowLimits2.minHeight_);
619 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::SetWindowLimitsDataRoute end ###");
620 }
621
622 /**
623 * @tc.name: SetAspectRatioDataRoute
624 * @tc.desc: test data route for SetAspectRatioDataRoute
625 * @tc.type: FUNC
626 */
627 HWTEST_F(WindowLayoutTest, SetAspectRatioDataRoute, Function | MediumTest | Level3)
628 {
629 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::SetAspectRatioDataRoute begin ###");
630 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
631 option->SetWindowName("SetAspectRatioDataRoute");
632 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
633 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
634
635 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
636 windowSceneSessionImpl->property_->SetPersistentId(1);
637 windowSceneSessionImpl->property_->SetDisplayId(0);
638
639 SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
640 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
641
642 windowSceneSessionImpl->hostSession_ = session;
643 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
644
645 WindowLimits windowLimits1 = {4000, 4000, 2000, 2000, 0.0f, 0.0f};
646 WMError ret = windowSceneSessionImpl->SetWindowLimits(windowLimits1, false);
647 EXPECT_EQ(WMError::WM_OK, ret);
648 const float ratio = 1.5;
649
650 ret = windowSceneSessionImpl->SetAspectRatio(ratio);
651 EXPECT_EQ(WMError::WM_OK, ret);
652 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::SetAspectRatioDataRoute end ###");
653 }
654
655 /**
656 * @tc.name: moveToDataRoute
657 * @tc.desc: test data route for moveTo
658 * @tc.type: FUNC
659 */
660 HWTEST_F(WindowLayoutTest, moveToDataRoute, Function | MediumTest | Level3)
661 {
662 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::moveToDataRoute begin ###");
663 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
664 option->SetWindowName("moveToDataRoute");
665 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
666 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
667 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
668 windowSceneSessionImpl->property_->SetPersistentId(1);
669 windowSceneSessionImpl->property_->SetDisplayId(0);
670
671 SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
672 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
673
674 windowSceneSessionImpl->hostSession_ = session;
675 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
676
677 WMError ret = windowSceneSessionImpl->MoveTo(500, 500);
678 usleep(WAIT_SERVERAL_FRAMES);
679 EXPECT_EQ(WMError::WM_OK, ret);
680
681 Rect rect = windowSceneSessionImpl->property_->GetRequestRect();
682 EXPECT_EQ(500, rect.posX_);
683 EXPECT_EQ(500, rect.posY_);
684 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::moveToDataRoute end ###");
685 }
686
687 /**
688 * @tc.name: ResizeDataRoute
689 * @tc.desc: test data route for Resize
690 * @tc.type: FUNC
691 */
692 HWTEST_F(WindowLayoutTest, ResizeDataRoute, Function | MediumTest | Level3)
693 {
694 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::ResizeDataRoute begin ###");
695 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
696 option->SetWindowName("ResizeDataRoute");
697 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
698 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
699 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
700 windowSceneSessionImpl->property_->SetPersistentId(1);
701 windowSceneSessionImpl->property_->SetDisplayId(0);
702
703 SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
704 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
705 session->isActive_ = true;
706 session->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
707 session->SetSessionState(SessionState::STATE_FOREGROUND);
708 windowSceneSessionImpl->hostSession_ = session;
709 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
710
711 WMError ret = windowSceneSessionImpl->Resize(500, 500);
712 EXPECT_EQ(WMError::WM_OK, ret);
713
714 Rect rect = windowSceneSessionImpl->property_->GetRequestRect();
715 EXPECT_EQ(500, rect.width_);
716 EXPECT_EQ(500, rect.height_);
717
718 WSRect wsRect = { rect.posX_, rect.posY_, rect.width_, rect.height_ };
719 WSError ret2 = session->UpdateSessionRect(wsRect, SizeChangeReason::RESIZE, false);
720 EXPECT_EQ(WSError::WS_OK, ret2);
721
722 usleep(WAIT_SERVERAL_FRAMES);
723 Rect rect2 = session->property_->GetRequestRect();
724 EXPECT_EQ(500, rect2.width_);
725 EXPECT_EQ(500, rect2.height_);
726 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::ResizeDataRoute end ###");
727 }
728
729 /**
730 * @tc.name: AdjustRectByAspectRatio
731 * @tc.desc: test AdjustRectByAspectRatio
732 * @tc.type: FUNC
733 */
734 HWTEST_F(WindowLayoutTest, AdjustRectByAspectRatio, Function | MediumTest | Level0)
735 {
736 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::AdjustRectByAspectRatio begin ###");
737 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
738 option->SetWindowName("AdjustRectByAspectRatio");
739 option->SetWindowType(WindowType::APP_WINDOW_BASE);
740 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
741 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
742 windowSceneSessionImpl->property_->SetPersistentId(1);
743 windowSceneSessionImpl->property_->SetDisplayId(0);
744
745 SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
746 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
747 session->isActive_ = true;
748 session->property_->SetWindowType(WindowType::APP_WINDOW_BASE);
749 session->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
750 session->SetSessionState(SessionState::STATE_FOREGROUND);
751
752 windowSceneSessionImpl->hostSession_ = session;
753 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
754
755 WindowLimits windowLimits1 = {3000, 3000, 1200, 1200, 0.0f, 0.0f};
756 WMError wmRet1 = windowSceneSessionImpl->SetWindowLimits(windowLimits1, false);
757 EXPECT_EQ(WMError::WM_OK, wmRet1);
758
759 WMError wmRet2 = windowSceneSessionImpl->Resize(1600, 1600);
760 EXPECT_EQ(WMError::WM_OK, wmRet2);
761
762 float ratio = 0.8;
763 WMError wmRet3 = windowSceneSessionImpl->SetAspectRatio(ratio);
764 EXPECT_EQ(WMError::WM_OK, wmRet3);
765
766 // 服务端执行相同的逻辑
767 auto property = windowSceneSessionImpl->property_;
768 WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_WINDOW_LIMITS;
769 WMError wsRet1 = session->UpdateSessionPropertyByAction(property, action);
770 EXPECT_EQ(WMError::WM_OK, wsRet1);
771
772 Rect rect = windowSceneSessionImpl->property_->GetRequestRect();
773 WSRect wsRect = { rect.posX_, rect.posY_, rect.width_, rect.height_ };
774 // 异步接口加一个延迟
775 WSError wsRet2 = session->UpdateSessionRect(wsRect, SizeChangeReason::RESIZE, false);
776 EXPECT_EQ(WSError::WS_OK, wsRet2);
777 usleep(WAIT_SERVERAL_FRAMES);
778 WSError wsRet3 = session->UpdateRect(wsRect, SizeChangeReason::RESIZE, "AdjustRectByAspectRatio", nullptr);
779 EXPECT_EQ(WSError::WS_OK, wsRet3);
780 usleep(WAIT_SERVERAL_FRAMES);
781 WSError wsRet4 = session->SetAspectRatio(ratio);
782 EXPECT_EQ(WSError::WS_OK, wsRet4);
783 TLOGI(WmsLogTag::WMS_LAYOUT, "### WindowLayoutTest::AdjustRectByAspectRatio end ###");
784 }
785
786 }
787 } // namespace Rosen
788 } // namespace OHOS
789