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