1 /*
2 * Copyright (c) 2023-2023 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 "mock_RSIWindowAnimationController.h"
18
19 #include "remote_animation.h"
20 #include "scene_board_judgement.h"
21 #include "session_manager.h"
22 #include "starting_window.h"
23 #include "window_adapter.h"
24 #include "window_agent.h"
25 #include "window_property.h"
26 #include "window_transition_info.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Rosen {
33 constexpr uint32_t WINDOW_ID = 1000;
34 class WindowAdapterTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40 };
41
SetUpTestCase()42 void WindowAdapterTest::SetUpTestCase() {}
43
TearDownTestCase()44 void WindowAdapterTest::TearDownTestCase() {}
45
SetUp()46 void WindowAdapterTest::SetUp() {}
47
TearDown()48 void WindowAdapterTest::TearDown() {}
49
50 namespace {
51 /**
52 * @tc.name: AddWindow
53 * @tc.desc: WindowAdapter/AddWindow
54 * @tc.type: FUNC
55 */
56 HWTEST_F(WindowAdapterTest, AddWindow, Function | SmallTest | Level2)
57 {
58 sptr<WindowProperty> windowProperty = nullptr;
59 WindowAdapter windowAdapter;
60
61 windowAdapter.AddWindow(windowProperty);
62 auto ret = windowAdapter.InitWMSProxy();
63 ASSERT_EQ(true, ret);
64 }
65
66 /**
67 * @tc.name: RemoveWindow
68 * @tc.desc: WindowAdapter/RemoveWindow
69 * @tc.type: FUNC
70 */
71 HWTEST_F(WindowAdapterTest, RemoveWindow, Function | SmallTest | Level2)
72 {
73 uint32_t windowId = 0;
74 bool isFromInnerkits = false;
75 WindowAdapter windowAdapter;
76
77 windowAdapter.RemoveWindow(windowId, isFromInnerkits);
78 auto ret = windowAdapter.InitWMSProxy();
79 ASSERT_EQ(true, ret);
80 }
81
82 /**
83 * @tc.name: RequestFocus
84 * @tc.desc: WindowAdapter/RequestFocus
85 * @tc.type: FUNC
86 */
87 HWTEST_F(WindowAdapterTest, RequestFocus, Function | SmallTest | Level2)
88 {
89 uint32_t windowId = 0;
90 WindowAdapter windowAdapter;
91
92 windowAdapter.RequestFocus(windowId);
93 auto ret = windowAdapter.InitWMSProxy();
94 ASSERT_EQ(true, ret);
95 }
96
97 /**
98 * @tc.name: RequestFocusStatusBySA
99 * @tc.desc: WindowAdapter/RequestFocusStatusBySA
100 * @tc.type: FUNC
101 */
102 HWTEST_F(WindowAdapterTest, RequestFocusStatusBySA, Function | SmallTest | Level2)
103 {
104 WindowAdapter windowAdapter;
105 int32_t persistentId = 1;
106 bool isFocused = true;
107 bool byForeground = true;
108 FocusChangeReason reason = FocusChangeReason::CLICK;
109
110 auto result = windowAdapter.RequestFocusStatusBySA(
111 persistentId, isFocused, byForeground, reason);
112 EXPECT_EQ(result, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
113 }
114
115 /**
116 * @tc.name: GetUIContentRemoteObj
117 * @tc.desc: WindowAdapter/GetUIContentRemoteObj
118 * @tc.type: FUNC
119 */
120 HWTEST_F(WindowAdapterTest, GetUIContentRemoteObj, Function | SmallTest | Level2)
121 {
122 WindowAdapter windowAdapter;
123 windowAdapter.isProxyValid_ = true;
124 windowAdapter.windowManagerServiceProxy_ = nullptr;
125 sptr<IRemoteObject> remoteObj;
126 auto ret = windowAdapter.GetUIContentRemoteObj(WINDOW_ID, remoteObj);
127 ASSERT_EQ(ret, WMError::WM_ERROR_SAMGR);
128 }
129
130 /**
131 * @tc.name: CheckWindowId
132 * @tc.desc: WindowAdapter/CheckWindowId
133 * @tc.type: FUNC
134 */
135 HWTEST_F(WindowAdapterTest, CheckWindowId, Function | SmallTest | Level2)
136 {
137 int32_t windowId = 0;
138 int32_t pid = 0;
139 WindowAdapter windowAdapter;
140
141 windowAdapter.CheckWindowId(windowId, pid);
142 auto ret = windowAdapter.InitWMSProxy();
143 ASSERT_EQ(true, ret);
144 }
145
146 /**
147 * @tc.name: SkipSnapshotForAppProcess
148 * @tc.desc: WindowAdapter/SkipSnapshotForAppProcess
149 * @tc.type: FUNC
150 */
151 HWTEST_F(WindowAdapterTest, SkipSnapshotForAppProcess, Function | SmallTest | Level2)
152 {
153 int32_t pid = 1000;
154 bool skip = true;
155 WindowAdapter windowAdapter;
156 windowAdapter.SkipSnapshotForAppProcess(pid, skip);
157 auto ret = windowAdapter.InitWMSProxy();
158 ASSERT_EQ(true, ret);
159 }
160
161 /**
162 * @tc.name: SetWindowAnimationController
163 * @tc.desc: WindowAdapter/SetWindowAnimationController
164 * @tc.type: FUNC
165 */
166 HWTEST_F(WindowAdapterTest, SetWindowAnimationController, Function | SmallTest | Level2)
167 {
168 sptr<RSIWindowAnimationController> controller = nullptr;
169 WindowAdapter windowAdapter;
170
171 windowAdapter.SetWindowAnimationController(controller);
172 auto ret = windowAdapter.InitWMSProxy();
173 ASSERT_EQ(true, ret);
174 }
175
176 /**
177 * @tc.name: GetAvoidAreaByType
178 * @tc.desc: WindowAdapter/GetAvoidAreaByType
179 * @tc.type: FUNC
180 */
181 HWTEST_F(WindowAdapterTest, GetAvoidAreaByType, Function | SmallTest | Level2)
182 {
183 uint32_t windowId = 0;
184 AvoidAreaType type = AvoidAreaType::TYPE_CUTOUT;
185 AvoidArea avoidArea;
186 WindowAdapter windowAdapter;
187
188 windowAdapter.GetAvoidAreaByType(windowId, type, avoidArea);
189 auto ret = windowAdapter.InitWMSProxy();
190 ASSERT_EQ(true, ret);
191 }
192
193 /**
194 * @tc.name: NotifyServerReadyToMoveOrDrag
195 * @tc.desc: WindowAdapter/NotifyServerReadyToMoveOrDrag
196 * @tc.type: FUNC
197 */
198 HWTEST_F(WindowAdapterTest, NotifyServerReadyToMoveOrDrag, Function | SmallTest | Level2)
199 {
200 uint32_t windowId = 0;
201 sptr<WindowProperty> windowProperty = nullptr;
202 sptr<MoveDragProperty> moveDragProperty = nullptr;
203 WindowAdapter windowAdapter;
204
205 windowAdapter.NotifyServerReadyToMoveOrDrag(windowId, windowProperty, moveDragProperty);
206 auto ret = windowAdapter.InitWMSProxy();
207 ASSERT_EQ(true, ret);
208 }
209
210 /**
211 * @tc.name: ProcessPointDown
212 * @tc.desc: WindowAdapter/ProcessPointDown
213 * @tc.type: FUNC
214 */
215 HWTEST_F(WindowAdapterTest, ProcessPointDown, Function | SmallTest | Level2)
216 {
217 uint32_t windowId = 0;
218 bool isPointDown = false;
219 WindowAdapter windowAdapter;
220
221 windowAdapter.ProcessPointDown(windowId, isPointDown);
222 windowAdapter.ProcessPointUp(windowId);
223 auto ret = windowAdapter.InitWMSProxy();
224 ASSERT_EQ(true, ret);
225 }
226
227 /**
228 * @tc.name: ToggleShownStateForAllAppWindows
229 * @tc.desc: WindowAdapter/ToggleShownStateForAllAppWindows
230 * @tc.type: FUNC
231 */
232 HWTEST_F(WindowAdapterTest, ToggleShownStateForAllAppWindows, Function | SmallTest | Level2)
233 {
234 WindowAdapter windowAdapter;
235
236 windowAdapter.ToggleShownStateForAllAppWindows();
237 auto ret = windowAdapter.InitWMSProxy();
238 ASSERT_EQ(true, ret);
239 }
240
241 /**
242 * @tc.name: GetSnapshotByWindowId
243 * @tc.desc: WindowAdapter/GetSnapshotByWindowId
244 * @tc.type: FUNC
245 */
246 HWTEST_F(WindowAdapterTest, GetSnapshotByWindowId, Function | SmallTest | Level2)
247 {
248 WindowAdapter windowAdapter;
249 int32_t persistentId = -1;
250 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
251 windowAdapter.GetSnapshotByWindowId(persistentId, pixelMap);
252 auto ret = windowAdapter.InitWMSProxy();
253 ASSERT_EQ(true, ret);
254 }
255
256 /**
257 * @tc.name: InitWMSProxy
258 * @tc.desc: WindowAdapter/InitWMSProxy
259 * @tc.type: FUNC
260 */
261 HWTEST_F(WindowAdapterTest, InitWMSProxy, Function | SmallTest | Level2)
262 {
263 WindowAdapter windowAdapter;
264 auto ret = windowAdapter.InitWMSProxy();
265 ASSERT_EQ(true, ret);
266 }
267
268 /**
269 * @tc.name: RegisterSessionRecoverCallbackFunc
270 * @tc.desc: WindowAdapter/RegisterSessionRecoverCallbackFunc
271 * @tc.type: FUNC
272 */
273 HWTEST_F(WindowAdapterTest, RegisterSessionRecoverCallbackFunc, Function | SmallTest | Level2)
274 {
275 WindowAdapter windowAdapter;
276 int32_t persistentId = 1;
__anonbe09d1d00202null277 auto testFunc = [] { return WMError::WM_OK; };
278 windowAdapter.RegisterSessionRecoverCallbackFunc(persistentId, testFunc);
279 ASSERT_NE(windowAdapter.sessionRecoverCallbackFuncMap_[persistentId], nullptr);
280 }
281
282 /**
283 * @tc.name: WindowManagerAndSessionRecover
284 * @tc.desc: WindowAdapter/WindowManagerAndSessionRecover
285 * @tc.type: FUNC
286 */
287 HWTEST_F(WindowAdapterTest, WindowManagerAndSessionRecover, Function | SmallTest | Level2)
288 {
289 WindowAdapter windowAdapter;
290 int32_t persistentId = 1;
291 int32_t ret = 0;
__anonbe09d1d00302null292 auto testFunc = [&ret] {
293 ret = 1;
294 return WMError::WM_DO_NOTHING;
295 };
296
__anonbe09d1d00402null297 auto testFunc2 = [&ret] {
298 ret = 2;
299 return WMError::WM_OK;
300 };
301 windowAdapter.RegisterSessionRecoverCallbackFunc(persistentId, testFunc);
302 windowAdapter.WindowManagerAndSessionRecover();
303 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
304 ASSERT_EQ(ret, 1);
305 }
306 windowAdapter.RegisterSessionRecoverCallbackFunc(persistentId, testFunc2);
307 windowAdapter.WindowManagerAndSessionRecover();
308 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
309 ASSERT_EQ(ret, 2);
310 } else {
311 ASSERT_EQ(ret, 0);
312 }
313 }
314
315 /**
316 * @tc.name: GetUnreliableWindowInfo
317 * @tc.desc: WindowAdapter/GetUnreliableWindowInfo
318 * @tc.type: FUNC
319 */
320 HWTEST_F(WindowAdapterTest, GetUnreliableWindowInfo, Function | SmallTest | Level2)
321 {
322 int32_t windowId = 0;
323 std::vector<sptr<UnreliableWindowInfo>> infos;
324 WindowAdapter windowAdapter;
325 windowAdapter.GetUnreliableWindowInfo(windowId, infos);
326 auto ret = windowAdapter.InitWMSProxy();
327 ASSERT_EQ(true, ret);
328 }
329
330 /**
331 * @tc.name: DestroyAndDisconnectSpecificSession
332 * @tc.desc: WindowAdapter/DestroyAndDisconnectSpecificSession
333 * @tc.type: FUNC
334 */
335 HWTEST_F(WindowAdapterTest, DestroyAndDisconnectSpecificSession, Function | SmallTest | Level2)
336 {
337 uint32_t persistentId = 0;
338 WindowAdapter windowAdapter;
339 windowAdapter.DestroyAndDisconnectSpecificSession(persistentId);
340 auto ret = windowAdapter.InitWMSProxy();
341 ASSERT_EQ(true, ret);
342 }
343
344 /**
345 * @tc.name: DestroyAndDisconnectSpecificSessionWithDetachCallback
346 * @tc.desc: WindowAdapter/DestroyAndDisconnectSpecificSessionWithDetachCallback
347 * @tc.type: FUNC
348 */
349 HWTEST_F(WindowAdapterTest, DestroyAndDisconnectSpecificSessionWithDetachCallback, Function | SmallTest | Level2)
350 {
351 uint32_t persistentId = 0;
352 WindowAdapter windowAdapter;
353 windowAdapter.DestroyAndDisconnectSpecificSessionWithDetachCallback(persistentId, nullptr);
354 auto ret = windowAdapter.InitWMSProxy();
355 ASSERT_EQ(true, ret);
356 }
357
358 /**
359 * @tc.name: UpdateModalExtensionRect
360 * @tc.desc: WindowAdapter/UpdateModalExtensionRect
361 * @tc.type: FUNC
362 */
363 HWTEST_F(WindowAdapterTest, UpdateModalExtensionRect, Function | SmallTest | Level2)
364 {
365 WindowAdapter windowAdapter;
366 Rect rect{ 1, 2, 3, 4 };
367 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
368 ASSERT_NE(token, nullptr);
369 windowAdapter.UpdateModalExtensionRect(token, rect);
370 windowAdapter.UpdateModalExtensionRect(nullptr, rect);
371 auto ret = windowAdapter.InitWMSProxy();
372 EXPECT_TRUE(ret);
373 }
374
375 /**
376 * @tc.name: ProcessModalExtensionPointDown
377 * @tc.desc: WindowAdapter/ProcessModalExtensionPointDown
378 * @tc.type: FUNC
379 */
380 HWTEST_F(WindowAdapterTest, ProcessModalExtensionPointDown, Function | SmallTest | Level2)
381 {
382 WindowAdapter windowAdapter;
383 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
384 ASSERT_NE(token, nullptr);
385 windowAdapter.ProcessModalExtensionPointDown(token, 0, 0);
386 windowAdapter.ProcessModalExtensionPointDown(nullptr, 0, 0);
387 auto ret = windowAdapter.InitWMSProxy();
388 EXPECT_TRUE(ret);
389 }
390
391 /**
392 * @tc.name: AddExtensionWindowStageToSCB
393 * @tc.desc: WindowAdapter/AddExtensionWindowStageToSCB
394 * @tc.type: FUNC
395 */
396 HWTEST_F(WindowAdapterTest, AddExtensionWindowStageToSCB, Function | SmallTest | Level2)
397 {
398 WindowAdapter windowAdapter;
399 windowAdapter.AddExtensionWindowStageToSCB(nullptr, nullptr, 0);
400 auto ret = windowAdapter.InitWMSProxy();
401 EXPECT_TRUE(ret);
402 }
403
404 /**
405 * @tc.name: RemoveExtensionWindowStageFromSCB
406 * @tc.desc: WindowAdapter/RemoveExtensionWindowStageFromSCB
407 * @tc.type: FUNC
408 */
409 HWTEST_F(WindowAdapterTest, RemoveExtensionWindowStageFromSCB, Function | SmallTest | Level2)
410 {
411 WindowAdapter windowAdapter;
412 windowAdapter.RemoveExtensionWindowStageFromSCB(nullptr, nullptr);
413 auto ret = windowAdapter.InitWMSProxy();
414 EXPECT_TRUE(ret);
415 }
416
417 /**
418 * @tc.name: AddOrRemoveSecureSession
419 * @tc.desc: WindowAdapter/AddOrRemoveSecureSession
420 * @tc.type: FUNC
421 */
422 HWTEST_F(WindowAdapterTest, AddOrRemoveSecureSession, Function | SmallTest | Level2)
423 {
424 int32_t persistentId = 0;
425 WindowAdapter windowAdapter;
426 windowAdapter.AddOrRemoveSecureSession(persistentId, true);
427 auto ret = windowAdapter.InitWMSProxy();
428 ASSERT_EQ(true, ret);
429 }
430
431 /**
432 * @tc.name: UpdateExtWindowFlags
433 * @tc.desc: WindowAdapter/UpdateExtWindowFlags
434 * @tc.type: FUNC
435 */
436 HWTEST_F(WindowAdapterTest, UpdateExtWindowFlags, Function | SmallTest | Level2)
437 {
438 WindowAdapter windowAdapter;
439 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
440 ASSERT_NE(token, nullptr);
441 windowAdapter.UpdateExtWindowFlags(token, 7, 7);
442 windowAdapter.UpdateExtWindowFlags(nullptr, 7, 7);
443 auto ret = windowAdapter.InitWMSProxy();
444 ASSERT_EQ(true, ret);
445 }
446
447 /**
448 * @tc.name: GetVisibilityWindowInfo
449 * @tc.desc: WindowAdapter/GetVisibilityWindowInfo
450 * @tc.type: FUNC
451 */
452 HWTEST_F(WindowAdapterTest, GetVisibilityWindowInfo, Function | SmallTest | Level2)
453 {
454 WindowAdapter windowAdapter;
455 std::vector<sptr<WindowVisibilityInfo>> infos;
456 auto ret = windowAdapter.GetVisibilityWindowInfo(infos);
457 windowAdapter.WindowManagerAndSessionRecover();
458 ASSERT_EQ(WMError::WM_OK, ret);
459 }
460
461 /**
462 * @tc.name: ReregisterWindowManagerAgent
463 * @tc.desc: WindowAdapter/ReregisterWindowManagerAgent
464 * @tc.type: FUNC
465 */
466 HWTEST_F(WindowAdapterTest, ReregisterWindowManagerAgent, Function | SmallTest | Level2)
467 {
468 WindowAdapter windowAdapter;
469 auto displayId = 0;
470 ModeChangeHotZones hotZones;
471 auto ret = windowAdapter.GetModeChangeHotZones(displayId, hotZones);
472 windowAdapter.ReregisterWindowManagerAgent();
473 ASSERT_EQ(WMError::WM_OK, ret);
474 }
475
476 /**
477 * @tc.name: RecoverAndReconnectSceneSession
478 * @tc.desc: WindowAdapter/RecoverAndReconnectSceneSession
479 * @tc.type: FUNC
480 */
481 HWTEST_F(WindowAdapterTest, RecoverAndReconnectSceneSession, Function | SmallTest | Level2)
482 {
483 WindowAdapter windowAdapter;
484 sptr<ISessionStage> iSessionStage;
485 sptr<IWindowEventChannel> eventChannel;
486 sptr<ISession> session = nullptr;
487 sptr<IRemoteObject> token = nullptr;
488 auto ret1 =
489 windowAdapter.RecoverAndReconnectSceneSession(iSessionStage, eventChannel, nullptr, session, nullptr, token);
490 ASSERT_EQ(ret1, WMError::WM_OK);
491
492 windowAdapter.isProxyValid_ = true;
493 auto ret2 =
494 windowAdapter.RecoverAndReconnectSceneSession(iSessionStage, eventChannel, nullptr, session, nullptr, token);
495 ASSERT_EQ(ret2, WMError::WM_OK);
496
497 sptr<IRemoteObject> remotObject = nullptr;
498 windowAdapter.windowManagerServiceProxy_ = iface_cast<IWindowManager>(remotObject);
499 auto ret3 =
500 windowAdapter.RecoverAndReconnectSceneSession(iSessionStage, eventChannel, nullptr, session, nullptr, token);
501 ASSERT_EQ(ret3, WMError::WM_DO_NOTHING);
502 }
503
504 /**
505 * @tc.name: UpdateProperty
506 * @tc.desc: WindowAdapter/UpdateProperty
507 * @tc.type: FUNC
508 */
509 HWTEST_F(WindowAdapterTest, UpdateProperty, Function | SmallTest | Level2)
510 {
511 WindowAdapter windowAdapter;
512 sptr<WindowProperty> windowProperty = sptr<WindowProperty>::MakeSptr();
513 PropertyChangeAction action = PropertyChangeAction::ACTION_UPDATE_RECT;
514 auto ret = windowAdapter.UpdateProperty(windowProperty, action);
515 windowAdapter.OnUserSwitch();
516 windowAdapter.ClearWindowAdapter();
517 ASSERT_EQ(WMError::WM_OK, ret);
518 }
519
520 /**
521 * @tc.name: SetWindowGravity
522 * @tc.desc: WindowAdapter/SetWindowGravity
523 * @tc.type: FUNC
524 */
525 HWTEST_F(WindowAdapterTest, SetWindowGravity, Function | SmallTest | Level2)
526 {
527 WindowAdapter windowAdapter;
528 windowAdapter.isProxyValid_ = true;
529 windowAdapter.windowManagerServiceProxy_ = nullptr;
530 uint32_t windowId = 0;
531 WindowGravity gravity = WindowGravity::WINDOW_GRAVITY_FLOAT;
532 uint32_t percent = 0;
533 auto ret = windowAdapter.SetWindowGravity(windowId, gravity, percent);
534 ASSERT_EQ(WMError::WM_ERROR_SAMGR, ret);
535 }
536
537 /**
538 * @tc.name: NotifyWindowTransition
539 * @tc.desc: WindowAdapter/NotifyWindowTransition
540 * @tc.type: FUNC
541 */
542 HWTEST_F(WindowAdapterTest, NotifyWindowTransition, Function | SmallTest | Level2)
543 {
544 WindowAdapter windowAdapter;
545 windowAdapter.isProxyValid_ = true;
546 windowAdapter.windowManagerServiceProxy_ = nullptr;
547 sptr<WindowTransitionInfo> from = nullptr;
548 sptr<WindowTransitionInfo> to = nullptr;
549 auto ret = windowAdapter.NotifyWindowTransition(from, to);
550 ASSERT_EQ(WMError::WM_ERROR_SAMGR, ret);
551 }
552
553 /**
554 * @tc.name: RaiseToAppTop
555 * @tc.desc: WindowAdapter/RaiseToAppTop
556 * @tc.type: FUNC
557 */
558 HWTEST_F(WindowAdapterTest, RaiseToAppTop, Function | SmallTest | Level2)
559 {
560 WindowAdapter windowAdapter;
561 uint32_t windowId = 0;
562
563 windowAdapter.isProxyValid_ = true;
564 auto ret = windowAdapter.RaiseToAppTop(windowId);
565 ASSERT_EQ(WMError::WM_ERROR_SAMGR, ret);
566 windowAdapter.isProxyValid_ = false;
567
568 ret = windowAdapter.RaiseToAppTop(windowId);
569 std::shared_ptr<MMI::KeyEvent> event = nullptr;
570 windowAdapter.DispatchKeyEvent(windowId, event);
571 ASSERT_EQ(WMError::WM_OK, ret);
572 }
573
574 /**
575 * @tc.name: GetSnapshot
576 * @tc.desc: WindowAdapter/GetSnapshot
577 * @tc.type: FUNC
578 */
579 HWTEST_F(WindowAdapterTest, GetSnapshot, Function | SmallTest | Level2)
580 {
581 WindowAdapter windowAdapter;
582 int32_t windowId = 0;
583 auto ret = windowAdapter.GetSnapshot(windowId);
584 ASSERT_EQ(nullptr, ret);
585 }
586
587 /**
588 * @tc.name: GetWindowAnimationTargets
589 * @tc.desc: WindowAdapter/GetWindowAnimationTargets
590 * @tc.type: FUNC
591 */
592 HWTEST_F(WindowAdapterTest, GetWindowAnimationTargets, Function | SmallTest | Level2)
593 {
594 WindowAdapter windowAdapter;
595 std::vector<uint32_t> missionIds;
596 std::vector<sptr<RSWindowAnimationTarget>> targets;
597 auto ret = windowAdapter.GetWindowAnimationTargets(missionIds, targets);
598 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
599 ASSERT_EQ(WMError::WM_OK, ret);
600 } else {
601 ASSERT_EQ(WMError::WM_ERROR_NO_MEM, ret);
602 }
603 }
604
605 /**
606 * @tc.name: GetMaximizeMode
607 * @tc.desc: WindowAdapter/GetMaximizeMode
608 * @tc.type: FUNC
609 */
610 HWTEST_F(WindowAdapterTest, GetMaximizeMode, Function | SmallTest | Level2)
611 {
612 WindowAdapter windowAdapter;
613 windowAdapter.isProxyValid_ = true;
614 windowAdapter.windowManagerServiceProxy_ = nullptr;
615 auto ret = windowAdapter.GetMaximizeMode();
616 ASSERT_EQ(MaximizeMode::MODE_FULL_FILL, ret);
617 }
618
619 /**
620 * @tc.name: UpdateSessionAvoidAreaListener
621 * @tc.desc: WindowAdapter/UpdateSessionAvoidAreaListener
622 * @tc.type: FUNC
623 */
624 HWTEST_F(WindowAdapterTest, UpdateSessionAvoidAreaListener, Function | SmallTest | Level2)
625 {
626 WindowAdapter windowAdapter;
627 windowAdapter.isProxyValid_ = true;
628 windowAdapter.windowManagerServiceProxy_ = nullptr;
629 int32_t persistentId = 0;
630 bool haveListener = true;
631 auto ret = windowAdapter.UpdateSessionAvoidAreaListener(persistentId, haveListener);
632 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
633 }
634
635 /**
636 * @tc.name: UpdateSessionTouchOutsideListener
637 * @tc.desc: WindowAdapter/UpdateSessionTouchOutsideListener
638 * @tc.type: FUNC
639 */
640 HWTEST_F(WindowAdapterTest, UpdateSessionTouchOutsideListener, Function | SmallTest | Level2)
641 {
642 WindowAdapter windowAdapter;
643 windowAdapter.isProxyValid_ = true;
644 windowAdapter.windowManagerServiceProxy_ = nullptr;
645 int32_t persistentId = 0;
646 bool haveListener = true;
647 auto ret = windowAdapter.UpdateSessionTouchOutsideListener(persistentId, haveListener);
648 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
649 }
650
651 /**
652 * @tc.name: SetSessionGravity
653 * @tc.desc: WindowAdapter/SetSessionGravity
654 * @tc.type: FUNC
655 */
656 HWTEST_F(WindowAdapterTest, SetSessionGravity, Function | SmallTest | Level2)
657 {
658 WindowAdapter windowAdapter;
659 int32_t persistentId = 0;
660 SessionGravity gravity = SessionGravity::SESSION_GRAVITY_FLOAT;
661 uint32_t percent = 0;
662 auto ret = windowAdapter.SetSessionGravity(persistentId, gravity, percent);
663 ASSERT_EQ(WMError::WM_OK, ret);
664 }
665
666 /**
667 * @tc.name: BindDialogSessionTarget
668 * @tc.desc: WindowAdapter/BindDialogSessionTarget
669 * @tc.type: FUNC
670 */
671 HWTEST_F(WindowAdapterTest, BindDialogSessionTarget, Function | SmallTest | Level2)
672 {
673 WindowAdapter windowAdapter;
674 windowAdapter.isProxyValid_ = true;
675 windowAdapter.windowManagerServiceProxy_ = nullptr;
676 uint64_t persistentId = 0;
677 sptr<IRemoteObject> targetToken = nullptr;
678 auto ret = windowAdapter.BindDialogSessionTarget(persistentId, targetToken);
679 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
680 }
681
682 /**
683 * @tc.name: GetHostWindowRect
684 * @tc.desc: WindowAdapter/GetHostWindowRect
685 * @tc.type: FUNC
686 */
687 HWTEST_F(WindowAdapterTest, GetHostWindowRect, Function | SmallTest | Level2)
688 {
689 WindowAdapter windowAdapter;
690 int32_t hostWindowId = 0;
691 Rect rect = { 0, 0, 0, 0 };
692 auto ret = windowAdapter.GetHostWindowRect(hostWindowId, rect);
693 ASSERT_EQ(WMError::WM_OK, ret);
694 }
695
696 /**
697 * @tc.name: GetWindowStyleType
698 * @tc.desc: WindowAdapter/GetWindowStyleType
699 * @tc.type: FUNC
700 */
701 HWTEST_F(WindowAdapterTest, GetWindowStyleType, Function | SmallTest | Level2)
702 {
703 WindowAdapter windowAdapter;
704 WindowStyleType windowStyleType = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
705 windowAdapter.GetWindowStyleType(windowStyleType);
706 ASSERT_EQ(Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT, windowStyleType);
707 }
708
709 /**
710 * @tc.name: SetProcessWatermark
711 * @tc.desc: WindowAdapter/SetProcessWatermark
712 * @tc.type: FUNC
713 */
714 HWTEST_F(WindowAdapterTest, SetProcessWatermark, Function | SmallTest | Level2)
715 {
716 int32_t pid = 1000;
717 const std::string watermarkName = "SetProcessWatermarkName";
718 bool isEnabled = true;
719 WindowAdapter windowAdapter;
720 windowAdapter.SetProcessWatermark(pid, watermarkName, isEnabled);
721 auto ret = windowAdapter.InitWMSProxy();
722 ASSERT_EQ(true, ret);
723 }
724
725 /**
726 * @tc.name: UpdateScreenLockStatusForApp
727 * @tc.desc: WindowAdapter/UpdateScreenLockStatusForApp
728 * @tc.type: FUNC
729 */
730 HWTEST_F(WindowAdapterTest, UpdateScreenLockStatusForApp, Function | SmallTest | Level2)
731 {
732 WindowAdapter windowAdapter;
733 auto err = windowAdapter.UpdateScreenLockStatusForApp("", true);
734 ASSERT_EQ(err, WMError::WM_OK);
735 auto ret = windowAdapter.InitWMSProxy();
736 ASSERT_EQ(ret, true);
737 }
738
739 /**
740 * @tc.name: CreateAndConnectSpecificSession
741 * @tc.desc: WindowAdapter/CreateAndConnectSpecificSession
742 * @tc.type: FUNC
743 */
744 HWTEST_F(WindowAdapterTest, CreateAndConnectSpecificSession, Function | SmallTest | Level2)
745 {
746 WindowAdapter windowAdapter;
747 auto ret = windowAdapter.InitWMSProxy();
748 ASSERT_EQ(ret, true);
749
750 sptr<ISessionStage> sessionStage;
751 sptr<IWindowEventChannel> eventChannel;
752 std::shared_ptr<RSSurfaceNode> node;
753 sptr<WindowSessionProperty> property;
754 sptr<ISession> session;
755 SystemSessionConfig systemConfig;
756 sptr<IRemoteObject> token;
757 int32_t id = 101; // 101 is persistentId
758 windowAdapter.CreateAndConnectSpecificSession(
759 sessionStage, eventChannel, node, property, id, session, systemConfig, token);
760 ASSERT_EQ(session, nullptr);
761 }
762
763 /**
764 * @tc.name: IsPcWindow
765 * @tc.desc: WindowAdapter/IsPcWindow
766 * @tc.type: FUNC
767 */
768 HWTEST_F(WindowAdapterTest, IsPcWindow, Function | SmallTest | Level2)
769 {
770 WindowAdapter windowAdapter;
771 bool isPcWindow = false;
772 auto err = windowAdapter.IsPcWindow(isPcWindow);
773 ASSERT_EQ(err, WMError::WM_OK);
774 }
775
776 /**
777 * @tc.name: IsPcOrPadFreeMultiWindowMode
778 * @tc.desc: WindowAdapter/IsPcOrPadFreeMultiWindowMode
779 * @tc.type: FUNC
780 */
781 HWTEST_F(WindowAdapterTest, IsPcOrPadFreeMultiWindowMode, Function | SmallTest | Level2)
782 {
783 WindowAdapter windowAdapter;
784 bool isPcOrPadFreeMultiWindowMode = false;
785 auto err = windowAdapter.IsPcOrPadFreeMultiWindowMode(isPcOrPadFreeMultiWindowMode);
786 ASSERT_EQ(err, WMError::WM_OK);
787 auto ret = windowAdapter.InitWMSProxy();
788 ASSERT_EQ(ret, true);
789 }
790
791 /**
792 * @tc.name: IsWindowRectAutoSave
793 * @tc.desc: WindowAdapter/IsWindowRectAutoSave
794 * @tc.type: FUNC
795 */
796 HWTEST_F(WindowAdapterTest, IsWindowRectAutoSave, Function | SmallTest | Level2)
797 {
798 WindowAdapter windowAdapter;
799 std::string key = "com.example.recposentryEntryAbility";
800 bool enabled = false;
801 int persistentId = 1;
802 auto err = windowAdapter.IsWindowRectAutoSave(key, enabled, persistentId);
803 ASSERT_EQ(err, WMError::WM_OK);
804 auto ret = windowAdapter.InitWMSProxy();
805 ASSERT_EQ(ret, true);
806 }
807
808 /**
809 * @tc.name: GetDisplayIdByWindowId
810 * @tc.desc: WindowAdapter/GetDisplayIdByWindowId
811 * @tc.type: FUNC
812 */
813 HWTEST_F(WindowAdapterTest, GetDisplayIdByWindowId, Function | SmallTest | Level2)
814 {
815 WindowAdapter windowAdapter;
816 const std::vector<uint64_t> windowIds = { 1, 2 };
817 std::unordered_map<uint64_t, DisplayId> windowDisplayIdMap;
818 auto err = windowAdapter.GetDisplayIdByWindowId(windowIds, windowDisplayIdMap);
819 ASSERT_EQ(err, WMError::WM_OK);
820 }
821
822 /**
823 * @tc.name: SetGlobalDragResizeType
824 * @tc.desc: WindowAdapter/SetGlobalDragResizeType
825 * @tc.type: FUNC
826 */
827 HWTEST_F(WindowAdapterTest, SetGlobalDragResizeType, Function | SmallTest | Level2)
828 {
829 WindowAdapter windowAdapter;
830 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
831 auto err = windowAdapter.SetGlobalDragResizeType(dragResizeType);
832 ASSERT_EQ(err, WMError::WM_OK);
833 }
834
835 /**
836 * @tc.name: GetGlobalDragResizeType
837 * @tc.desc: WindowAdapter/GetGlobalDragResizeType
838 * @tc.type: FUNC
839 */
840 HWTEST_F(WindowAdapterTest, GetGlobalDragResizeType, Function | SmallTest | Level2)
841 {
842 WindowAdapter windowAdapter;
843 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
844 auto err = windowAdapter.GetGlobalDragResizeType(dragResizeType);
845 ASSERT_EQ(err, WMError::WM_OK);
846 }
847
848 /**
849 * @tc.name: SetAppDragResizeType
850 * @tc.desc: WindowAdapter/SetAppDragResizeType
851 * @tc.type: FUNC
852 */
853 HWTEST_F(WindowAdapterTest, SetAppDragResizeType, Function | SmallTest | Level2)
854 {
855 WindowAdapter windowAdapter;
856 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
857 const std::string bundleName = "test";
858 auto err = windowAdapter.SetAppDragResizeType(bundleName, dragResizeType);
859 ASSERT_EQ(err, WMError::WM_OK);
860 }
861
862 /**
863 * @tc.name: GetAppDragResizeType
864 * @tc.desc: WindowAdapter/GetAppDragResizeType
865 * @tc.type: FUNC
866 */
867 HWTEST_F(WindowAdapterTest, GetAppDragResizeType, Function | SmallTest | Level2)
868 {
869 WindowAdapter windowAdapter;
870 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
871 const std::string bundleName = "test";
872 auto err = windowAdapter.GetAppDragResizeType(bundleName, dragResizeType);
873 ASSERT_EQ(err, WMError::WM_OK);
874 }
875
876 /**
877 * @tc.name: SetParentWindow
878 * @tc.desc: WindowAdapter/SetParentWindow
879 * @tc.type: FUNC
880 */
881 HWTEST_F(WindowAdapterTest, SetParentWindow, Function | SmallTest | Level2)
882 {
883 WindowAdapter windowAdapter;
884 int32_t subWindowId = 1;
885 int32_t newParentWindowId = 2;
886 auto err = windowAdapter.SetParentWindow(subWindowId, newParentWindowId);
887 ASSERT_EQ(err, WMError::WM_OK);
888 }
889
890 /**
891 * @tc.name: MinimizeByWindowId
892 * @tc.desc: WindowAdapter/MinimizeByWindowId
893 * @tc.type: FUNC
894 */
895 HWTEST_F(WindowAdapterTest, MinimizeByWindowId, Function | SmallTest | Level2)
896 {
897 WindowAdapter windowAdapter;
898 std::vector<int32_t> windowIds;
899 auto err = windowAdapter.MinimizeByWindowId(windowIds);
900 ASSERT_EQ(WMError::WM_OK, err);
901 auto ret = windowAdapter.InitWMSProxy();
902 ASSERT_EQ(ret, true);
903 }
904
905 /**
906 * @tc.name: ListWindowInfo01
907 * @tc.desc: WindowAdapter/ListWindowInfo
908 * @tc.type: FUNC
909 */
910 HWTEST_F(WindowAdapterTest, ListWindowInfo01, Function | SmallTest | Level2)
911 {
912 WindowAdapter windowAdapter;
913 WindowInfoOption windowInfoOption;
914 std::vector<sptr<WindowInfo>> infos;
915 auto err = windowAdapter.ListWindowInfo(windowInfoOption, infos);
916 ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, err);
917 auto ret = windowAdapter.InitWMSProxy();
918 ASSERT_EQ(ret, true);
919 }
920 } // namespace
921 } // namespace Rosen
922 } // namespace OHOS