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 #include "ui_effect_controller_interface.h"
28 #include "ui_effect_controller_client.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 constexpr uint32_t WINDOW_ID = 1000;
36 class WindowAdapterTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 };
43
SetUpTestCase()44 void WindowAdapterTest::SetUpTestCase() {}
45
TearDownTestCase()46 void WindowAdapterTest::TearDownTestCase() {}
47
SetUp()48 void WindowAdapterTest::SetUp() {}
49
TearDown()50 void WindowAdapterTest::TearDown() {}
51
52 namespace {
53 /**
54 * @tc.name: AddWindow
55 * @tc.desc: WindowAdapter/AddWindow
56 * @tc.type: FUNC
57 */
58 HWTEST_F(WindowAdapterTest, AddWindow, TestSize.Level1)
59 {
60 sptr<WindowProperty> windowProperty = nullptr;
61 WindowAdapter windowAdapter;
62
63 windowAdapter.AddWindow(windowProperty);
64 auto ret = windowAdapter.InitWMSProxy();
65 ASSERT_EQ(true, ret);
66 }
67
68 /**
69 * @tc.name: RemoveWindow
70 * @tc.desc: WindowAdapter/RemoveWindow
71 * @tc.type: FUNC
72 */
73 HWTEST_F(WindowAdapterTest, RemoveWindow, TestSize.Level1)
74 {
75 uint32_t windowId = 0;
76 bool isFromInnerkits = false;
77 WindowAdapter windowAdapter;
78
79 windowAdapter.RemoveWindow(windowId, isFromInnerkits);
80 auto ret = windowAdapter.InitWMSProxy();
81 ASSERT_EQ(true, ret);
82 }
83
84 /**
85 * @tc.name: RequestFocus
86 * @tc.desc: WindowAdapter/RequestFocus
87 * @tc.type: FUNC
88 */
89 HWTEST_F(WindowAdapterTest, RequestFocus, TestSize.Level1)
90 {
91 uint32_t windowId = 0;
92 WindowAdapter windowAdapter;
93
94 windowAdapter.RequestFocus(windowId);
95 auto ret = windowAdapter.InitWMSProxy();
96 ASSERT_EQ(true, ret);
97 }
98
99 /**
100 * @tc.name: RequestFocusStatusBySA
101 * @tc.desc: WindowAdapter/RequestFocusStatusBySA
102 * @tc.type: FUNC
103 */
104 HWTEST_F(WindowAdapterTest, RequestFocusStatusBySA, TestSize.Level1)
105 {
106 WindowAdapter windowAdapter;
107 int32_t persistentId = 1;
108 bool isFocused = true;
109 bool byForeground = true;
110 FocusChangeReason reason = FocusChangeReason::CLICK;
111
112 auto result = windowAdapter.RequestFocusStatusBySA(
113 persistentId, isFocused, byForeground, reason);
114 EXPECT_EQ(result, WMError::WM_ERROR_INVALID_PERMISSION);
115 }
116
117 /**
118 * @tc.name: GetUIContentRemoteObj
119 * @tc.desc: WindowAdapter/GetUIContentRemoteObj
120 * @tc.type: FUNC
121 */
122 HWTEST_F(WindowAdapterTest, GetUIContentRemoteObj, TestSize.Level1)
123 {
124 WindowAdapter windowAdapter;
125 windowAdapter.isProxyValid_ = true;
126 windowAdapter.windowManagerServiceProxy_ = nullptr;
127 sptr<IRemoteObject> remoteObj;
128 auto ret = windowAdapter.GetUIContentRemoteObj(WINDOW_ID, remoteObj);
129 ASSERT_EQ(ret, WMError::WM_ERROR_SAMGR);
130 }
131
132 /**
133 * @tc.name: CheckWindowId
134 * @tc.desc: WindowAdapter/CheckWindowId
135 * @tc.type: FUNC
136 */
137 HWTEST_F(WindowAdapterTest, CheckWindowId, TestSize.Level1)
138 {
139 int32_t windowId = 0;
140 int32_t pid = 0;
141 WindowAdapter windowAdapter;
142
143 windowAdapter.CheckWindowId(windowId, pid);
144 auto ret = windowAdapter.InitWMSProxy();
145 ASSERT_EQ(true, ret);
146 }
147
148 /**
149 * @tc.name: GetAccessibilityWindowInfo
150 * @tc.desc: WindowAdapter/GetAccessibilityWindowInfo
151 * @tc.type: FUNC
152 */
153 HWTEST_F(WindowAdapterTest, GetAccessibilityWindowInfo, TestSize.Level1)
154 {
155 WindowAdapter windowAdapter;
156 std::vector<sptr<AccessibilityWindowInfo>> infos;
157 ASSERT_EQ(WMError::WM_OK, windowAdapter.GetAccessibilityWindowInfo(infos));
158 }
159
160 /**
161 * @tc.name: GetGlobalWindowMode
162 * @tc.desc: WindowAdapter/GetGlobalWindowMode
163 * @tc.type: FUNC
164 */
165 HWTEST_F(WindowAdapterTest, GetGlobalWindowMode, TestSize.Level1)
166 {
167 WindowAdapter windowAdapter;
168 GlobalWindowMode globalWinMode = GlobalWindowMode::UNKNOWN;
169 ASSERT_EQ(WMError::WM_OK, windowAdapter.GetGlobalWindowMode(0, globalWinMode));
170 }
171
172 /**
173 * @tc.name: SkipSnapshotForAppProcess
174 * @tc.desc: WindowAdapter/SkipSnapshotForAppProcess
175 * @tc.type: FUNC
176 */
177 HWTEST_F(WindowAdapterTest, SkipSnapshotForAppProcess, TestSize.Level1)
178 {
179 int32_t pid = 1000;
180 bool skip = true;
181 WindowAdapter windowAdapter;
182 windowAdapter.SkipSnapshotForAppProcess(pid, skip);
183 auto ret = windowAdapter.InitWMSProxy();
184 ASSERT_EQ(true, ret);
185 }
186
187 /**
188 * @tc.name: SetWindowAnimationController
189 * @tc.desc: WindowAdapter/SetWindowAnimationController
190 * @tc.type: FUNC
191 */
192 HWTEST_F(WindowAdapterTest, SetWindowAnimationController, TestSize.Level1)
193 {
194 sptr<RSIWindowAnimationController> controller = nullptr;
195 WindowAdapter windowAdapter;
196
197 windowAdapter.SetWindowAnimationController(controller);
198 auto ret = windowAdapter.InitWMSProxy();
199 ASSERT_EQ(true, ret);
200 }
201
202 /**
203 * @tc.name: GetAvoidAreaByType
204 * @tc.desc: WindowAdapter/GetAvoidAreaByType
205 * @tc.type: FUNC
206 */
207 HWTEST_F(WindowAdapterTest, GetAvoidAreaByType, TestSize.Level1)
208 {
209 uint32_t windowId = 0;
210 AvoidAreaType type = AvoidAreaType::TYPE_CUTOUT;
211 AvoidArea avoidArea;
212 WindowAdapter windowAdapter;
213
214 windowAdapter.GetAvoidAreaByType(windowId, type, avoidArea);
215 auto ret = windowAdapter.InitWMSProxy();
216 ASSERT_EQ(true, ret);
217 }
218
219 /**
220 * @tc.name: NotifyServerReadyToMoveOrDrag
221 * @tc.desc: WindowAdapter/NotifyServerReadyToMoveOrDrag
222 * @tc.type: FUNC
223 */
224 HWTEST_F(WindowAdapterTest, NotifyServerReadyToMoveOrDrag, TestSize.Level1)
225 {
226 uint32_t windowId = 0;
227 sptr<WindowProperty> windowProperty = nullptr;
228 sptr<MoveDragProperty> moveDragProperty = nullptr;
229 WindowAdapter windowAdapter;
230
231 windowAdapter.NotifyServerReadyToMoveOrDrag(windowId, windowProperty, moveDragProperty);
232 auto ret = windowAdapter.InitWMSProxy();
233 ASSERT_EQ(true, ret);
234 }
235
236 /**
237 * @tc.name: ProcessPointDown
238 * @tc.desc: WindowAdapter/ProcessPointDown
239 * @tc.type: FUNC
240 */
241 HWTEST_F(WindowAdapterTest, ProcessPointDown, TestSize.Level1)
242 {
243 uint32_t windowId = 0;
244 bool isPointDown = false;
245 WindowAdapter windowAdapter;
246
247 windowAdapter.ProcessPointDown(windowId, isPointDown);
248 windowAdapter.ProcessPointUp(windowId);
249 auto ret = windowAdapter.InitWMSProxy();
250 ASSERT_EQ(true, ret);
251 }
252
253 /**
254 * @tc.name: ToggleShownStateForAllAppWindows
255 * @tc.desc: WindowAdapter/ToggleShownStateForAllAppWindows
256 * @tc.type: FUNC
257 */
258 HWTEST_F(WindowAdapterTest, ToggleShownStateForAllAppWindows, TestSize.Level1)
259 {
260 WindowAdapter windowAdapter;
261
262 windowAdapter.ToggleShownStateForAllAppWindows();
263 auto ret = windowAdapter.InitWMSProxy();
264 ASSERT_EQ(true, ret);
265 }
266
267 /**
268 * @tc.name: GetSnapshotByWindowId
269 * @tc.desc: WindowAdapter/GetSnapshotByWindowId
270 * @tc.type: FUNC
271 */
272 HWTEST_F(WindowAdapterTest, GetSnapshotByWindowId, TestSize.Level1)
273 {
274 WindowAdapter windowAdapter;
275 int32_t persistentId = -1;
276 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
277 windowAdapter.GetSnapshotByWindowId(persistentId, pixelMap);
278 auto ret = windowAdapter.InitWMSProxy();
279 ASSERT_EQ(true, ret);
280 }
281
282 /**
283 * @tc.name: RegisterWMSConnectionChangedListener
284 * @tc.desc: WindowAdapter/RegisterWMSConnectionChangedListener
285 * @tc.type: FUNC
286 */
287 HWTEST_F(WindowAdapterTest, RegisterWMSConnectionChangedListener, TestSize.Level1)
288 {
289 WindowAdapter windowAdapter;
290 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowAdapter.RegisterWMSConnectionChangedListener(nullptr));
291 }
292
293 /**
294 * @tc.name: InitWMSProxy
295 * @tc.desc: WindowAdapter/InitWMSProxy
296 * @tc.type: FUNC
297 */
298 HWTEST_F(WindowAdapterTest, InitWMSProxy, TestSize.Level1)
299 {
300 WindowAdapter windowAdapter;
301 auto ret = windowAdapter.InitWMSProxy();
302 ASSERT_EQ(true, ret);
303 }
304
305 /**
306 * @tc.name: WindowManagerAndSessionRecover
307 * @tc.desc: WindowAdapter/WindowManagerAndSessionRecover
308 * @tc.type: FUNC
309 */
310 HWTEST_F(WindowAdapterTest, WindowManagerAndSessionRecover, TestSize.Level1)
311 {
312 WindowAdapter windowAdapter;
313 int32_t persistentId = 1;
314 int32_t ret = 0;
__anon71bce0f20202null315 auto testFunc = [&ret] {
316 ret += 1;
317 return WMError::WM_DO_NOTHING;
318 };
319
__anon71bce0f20302null320 auto testFunc2 = [&ret] {
321 ret += 1;
322 return WMError::WM_OK;
323 };
324
__anon71bce0f20402null325 auto testFunc3 = [] {
326 return WMError::WM_OK;
327 };
__anon71bce0f20502null328 auto testFunc4 = [] {
329 return WMError::WM_DO_NOTHING;
330 };
331 windowAdapter.RegisterSessionRecoverCallbackFunc(persistentId, testFunc);
332 windowAdapter.RegisterUIEffectRecoverCallbackFunc(persistentId, testFunc3);
333 windowAdapter.WindowManagerAndSessionRecover();
334 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
335 ASSERT_EQ(ret, 1);
336 }
337 windowAdapter.RegisterSessionRecoverCallbackFunc(persistentId, testFunc2);
338 windowAdapter.RegisterUIEffectRecoverCallbackFunc(persistentId, testFunc4);
339 windowAdapter.WindowManagerAndSessionRecover();
340 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
341 ASSERT_EQ(ret, 2);
342 }
343 }
344
345 /**
346 * @tc.name: GetUnreliableWindowInfo
347 * @tc.desc: WindowAdapter/GetUnreliableWindowInfo
348 * @tc.type: FUNC
349 */
350 HWTEST_F(WindowAdapterTest, GetUnreliableWindowInfo, TestSize.Level1)
351 {
352 int32_t windowId = 0;
353 std::vector<sptr<UnreliableWindowInfo>> infos;
354 WindowAdapter windowAdapter;
355 windowAdapter.GetUnreliableWindowInfo(windowId, infos);
356 auto ret = windowAdapter.InitWMSProxy();
357 ASSERT_EQ(true, ret);
358 }
359
360 /**
361 * @tc.name: RecoverAndConnectSpecificSession
362 * @tc.desc: WindowAdapter/RecoverAndConnectSpecificSession
363 * @tc.type: FUNC
364 */
365 HWTEST_F(WindowAdapterTest, RecoverAndConnectSpecificSession, TestSize.Level1)
366 {
367 WindowAdapter windowAdapter;
368 auto ret = windowAdapter.InitWMSProxy();
369 sptr<ISessionStage> sessionStage;
370 sptr<IWindowEventChannel> eventChannel;
371 std::shared_ptr<RSSurfaceNode> node;
372 sptr<WindowSessionProperty> property;
373 sptr<ISession> session;
374 SystemSessionConfig systemConfig;
375 sptr<IRemoteObject> token;
376 windowAdapter.RecoverAndConnectSpecificSession(
377 sessionStage, eventChannel, node, property, session, token);
378 ASSERT_EQ(ret, true);
379 }
380
381 /**
382 * @tc.name: DestroyAndDisconnectSpecificSession
383 * @tc.desc: WindowAdapter/DestroyAndDisconnectSpecificSession
384 * @tc.type: FUNC
385 */
386 HWTEST_F(WindowAdapterTest, DestroyAndDisconnectSpecificSession, TestSize.Level1)
387 {
388 uint32_t persistentId = 0;
389 WindowAdapter windowAdapter;
390 windowAdapter.DestroyAndDisconnectSpecificSession(persistentId);
391 auto ret = windowAdapter.InitWMSProxy();
392 ASSERT_EQ(true, ret);
393 }
394
395 /**
396 * @tc.name: DestroyAndDisconnectSpecificSessionWithDetachCallback
397 * @tc.desc: WindowAdapter/DestroyAndDisconnectSpecificSessionWithDetachCallback
398 * @tc.type: FUNC
399 */
400 HWTEST_F(WindowAdapterTest, DestroyAndDisconnectSpecificSessionWithDetachCallback, TestSize.Level1)
401 {
402 uint32_t persistentId = 0;
403 WindowAdapter windowAdapter;
404 windowAdapter.DestroyAndDisconnectSpecificSessionWithDetachCallback(persistentId, nullptr);
405 auto ret = windowAdapter.InitWMSProxy();
406 ASSERT_EQ(true, ret);
407 }
408
409 /**
410 * @tc.name: UpdateModalExtensionRect
411 * @tc.desc: WindowAdapter/UpdateModalExtensionRect
412 * @tc.type: FUNC
413 */
414 HWTEST_F(WindowAdapterTest, UpdateModalExtensionRect, TestSize.Level1)
415 {
416 WindowAdapter windowAdapter;
417 Rect rect{ 1, 2, 3, 4 };
418 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
419 ASSERT_NE(token, nullptr);
420 windowAdapter.UpdateModalExtensionRect(token, rect);
421 windowAdapter.UpdateModalExtensionRect(nullptr, rect);
422 auto ret = windowAdapter.InitWMSProxy();
423 EXPECT_TRUE(ret);
424 }
425
426 /**
427 * @tc.name: ProcessModalExtensionPointDown
428 * @tc.desc: WindowAdapter/ProcessModalExtensionPointDown
429 * @tc.type: FUNC
430 */
431 HWTEST_F(WindowAdapterTest, ProcessModalExtensionPointDown, TestSize.Level1)
432 {
433 WindowAdapter windowAdapter;
434 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
435 ASSERT_NE(token, nullptr);
436 windowAdapter.ProcessModalExtensionPointDown(token, 0, 0);
437 windowAdapter.ProcessModalExtensionPointDown(nullptr, 0, 0);
438 auto ret = windowAdapter.InitWMSProxy();
439 EXPECT_TRUE(ret);
440 }
441
442 /**
443 * @tc.name: AddExtensionWindowStageToSCB
444 * @tc.desc: WindowAdapter/AddExtensionWindowStageToSCB
445 * @tc.type: FUNC
446 */
447 HWTEST_F(WindowAdapterTest, AddExtensionWindowStageToSCB, TestSize.Level1)
448 {
449 WindowAdapter windowAdapter;
450 windowAdapter.AddExtensionWindowStageToSCB(nullptr, nullptr, 0);
451 auto ret = windowAdapter.InitWMSProxy();
452 EXPECT_TRUE(ret);
453 }
454
455 /**
456 * @tc.name: RemoveExtensionWindowStageFromSCB
457 * @tc.desc: WindowAdapter/RemoveExtensionWindowStageFromSCB
458 * @tc.type: FUNC
459 */
460 HWTEST_F(WindowAdapterTest, RemoveExtensionWindowStageFromSCB, TestSize.Level1)
461 {
462 WindowAdapter windowAdapter;
463 windowAdapter.RemoveExtensionWindowStageFromSCB(nullptr, nullptr);
464 auto ret = windowAdapter.InitWMSProxy();
465 EXPECT_TRUE(ret);
466 }
467
468 /**
469 * @tc.name: AddOrRemoveSecureSession
470 * @tc.desc: WindowAdapter/AddOrRemoveSecureSession
471 * @tc.type: FUNC
472 */
473 HWTEST_F(WindowAdapterTest, AddOrRemoveSecureSession, TestSize.Level1)
474 {
475 int32_t persistentId = 0;
476 WindowAdapter windowAdapter;
477 windowAdapter.AddOrRemoveSecureSession(persistentId, true);
478 auto ret = windowAdapter.InitWMSProxy();
479 ASSERT_EQ(true, ret);
480 }
481
482 /**
483 * @tc.name: UpdateExtWindowFlags
484 * @tc.desc: WindowAdapter/UpdateExtWindowFlags
485 * @tc.type: FUNC
486 */
487 HWTEST_F(WindowAdapterTest, UpdateExtWindowFlags, TestSize.Level1)
488 {
489 WindowAdapter windowAdapter;
490 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
491 ASSERT_NE(token, nullptr);
492 windowAdapter.UpdateExtWindowFlags(token, 7, 7);
493 windowAdapter.UpdateExtWindowFlags(nullptr, 7, 7);
494 auto ret = windowAdapter.InitWMSProxy();
495 ASSERT_EQ(true, ret);
496 }
497
498 /**
499 * @tc.name: GetVisibilityWindowInfo
500 * @tc.desc: WindowAdapter/GetVisibilityWindowInfo
501 * @tc.type: FUNC
502 */
503 HWTEST_F(WindowAdapterTest, GetVisibilityWindowInfo, TestSize.Level1)
504 {
505 WindowAdapter windowAdapter;
506 std::vector<sptr<WindowVisibilityInfo>> infos;
507 auto ret = windowAdapter.GetVisibilityWindowInfo(infos);
508 windowAdapter.WindowManagerAndSessionRecover();
509 ASSERT_EQ(WMError::WM_OK, ret);
510 }
511
512 /**
513 * @tc.name: RecoverWindowPropertyChangeFlag
514 * @tc.desc: WindowAdapter/RecoverWindowPropertyChangeFlag
515 * @tc.type: FUNC
516 */
517 HWTEST_F(WindowAdapterTest, RecoverWindowPropertyChangeFlag01, TestSize.Level1)
518 {
519 WindowAdapter windowAdapter;
520 auto ret = windowAdapter.RecoverWindowPropertyChangeFlag();
521 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
522
523 windowAdapter.InitWMSProxy();
524 ASSERT_NE(windowAdapter.windowManagerServiceProxy_, nullptr);
525 ret = windowAdapter.RecoverWindowPropertyChangeFlag();
526 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
527 }
528
529 /**
530 * @tc.name: ReregisterWindowManagerAgent
531 * @tc.desc: WindowAdapter/ReregisterWindowManagerAgent
532 * @tc.type: FUNC
533 */
534 HWTEST_F(WindowAdapterTest, ReregisterWindowManagerAgent, TestSize.Level1)
535 {
536 WindowAdapter windowAdapter;
537 auto displayId = 0;
538 ModeChangeHotZones hotZones;
539 auto ret = windowAdapter.GetModeChangeHotZones(displayId, hotZones);
540 windowAdapter.ReregisterWindowManagerAgent();
541
542 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_PROPERTY;
543 windowAdapter.windowManagerAgentMap_[type] = std::set<sptr<IWindowManagerAgent>>();
544 windowAdapter.ReregisterWindowManagerAgent();
545
546 ASSERT_EQ(WMError::WM_OK, ret);
547 }
548
549 /**
550 * @tc.name: UpdateProperty
551 * @tc.desc: WindowAdapter/UpdateProperty
552 * @tc.type: FUNC
553 */
554 HWTEST_F(WindowAdapterTest, UpdateProperty, TestSize.Level1)
555 {
556 WindowAdapter windowAdapter;
557 sptr<WindowProperty> windowProperty = sptr<WindowProperty>::MakeSptr();
558 PropertyChangeAction action = PropertyChangeAction::ACTION_UPDATE_RECT;
559 auto ret = windowAdapter.UpdateProperty(windowProperty, action);
560 windowAdapter.OnUserSwitch();
561 windowAdapter.ClearWindowAdapter();
562 ASSERT_EQ(WMError::WM_OK, ret);
563 }
564
565 /**
566 * @tc.name: SetWindowGravity
567 * @tc.desc: WindowAdapter/SetWindowGravity
568 * @tc.type: FUNC
569 */
570 HWTEST_F(WindowAdapterTest, SetWindowGravity, TestSize.Level1)
571 {
572 WindowAdapter windowAdapter;
573 WindowGravity gravity = WindowGravity::WINDOW_GRAVITY_FLOAT;
574 ASSERT_EQ(WMError::WM_OK, windowAdapter.SetWindowGravity(0, gravity, 0));
575 }
576
577 /**
578 * @tc.name: NotifyWindowTransition
579 * @tc.desc: WindowAdapter/NotifyWindowTransition
580 * @tc.type: FUNC
581 */
582 HWTEST_F(WindowAdapterTest, NotifyWindowTransition, TestSize.Level1)
583 {
584 WindowAdapter windowAdapter;
585 sptr<WindowTransitionInfo> from = sptr<WindowTransitionInfo>::MakeSptr();
586 sptr<WindowTransitionInfo> to = sptr<WindowTransitionInfo>::MakeSptr();
587 ASSERT_EQ(WMError::WM_OK, windowAdapter.NotifyWindowTransition(from, to));
588 }
589
590 /**
591 * @tc.name: MinimizeWindowsByLauncher
592 * @tc.desc: WindowAdapter/MinimizeWindowsByLauncher
593 * @tc.type: FUNC
594 */
595 HWTEST_F(WindowAdapterTest, MinimizeWindowsByLauncher, TestSize.Level1)
596 {
597 WindowAdapter windowAdapter;
598 auto ret = windowAdapter.InitWMSProxy();
599 std::vector<uint32_t> windowIds;
600 bool isAnimated = true;
601 sptr<RSIWindowAnimationFinishedCallback> finishCallback;
602 windowAdapter.MinimizeWindowsByLauncher(windowIds, isAnimated, finishCallback);
603 ASSERT_EQ(true, ret);
604 }
605
606 /**
607 * @tc.name: UpdateRsTree
608 * @tc.desc: WindowAdapter/UpdateRsTree
609 * @tc.type: FUNC
610 */
611 HWTEST_F(WindowAdapterTest, UpdateRsTree, TestSize.Level1)
612 {
613 WindowAdapter windowAdapter;
614 ASSERT_EQ(WMError::WM_OK, windowAdapter.UpdateRsTree(0, false));
615 }
616
617 /**
618 * @tc.name: BindDialogTarget
619 * @tc.desc: WindowAdapter/BindDialogTarget
620 * @tc.type: FUNC
621 */
622 HWTEST_F(WindowAdapterTest, BindDialogTarget, TestSize.Level1)
623 {
624 WindowAdapter windowAdapter;
625 sptr<IRemoteObject> targetToken;
626 uint32_t windowId = 0;
627 ASSERT_EQ(WMError::WM_OK, windowAdapter.BindDialogTarget(windowId, targetToken));
628 }
629
630 /**
631 * @tc.name: RaiseToAppTop
632 * @tc.desc: WindowAdapter/RaiseToAppTop
633 * @tc.type: FUNC
634 */
635 HWTEST_F(WindowAdapterTest, RaiseToAppTop, TestSize.Level1)
636 {
637 WindowAdapter windowAdapter;
638 uint32_t windowId = 0;
639
640 windowAdapter.isProxyValid_ = true;
641 auto ret = windowAdapter.RaiseToAppTop(windowId);
642 ASSERT_EQ(WMError::WM_ERROR_SAMGR, ret);
643 windowAdapter.isProxyValid_ = false;
644
645 ret = windowAdapter.RaiseToAppTop(windowId);
646 std::shared_ptr<MMI::KeyEvent> event = nullptr;
647 windowAdapter.DispatchKeyEvent(windowId, event);
648 ASSERT_EQ(WMError::WM_OK, ret);
649 }
650
651 /**
652 * @tc.name: GetSnapshot
653 * @tc.desc: WindowAdapter/GetSnapshot
654 * @tc.type: FUNC
655 */
656 HWTEST_F(WindowAdapterTest, GetSnapshot, TestSize.Level1)
657 {
658 WindowAdapter windowAdapter;
659 int32_t windowId = 0;
660 auto ret = windowAdapter.GetSnapshot(windowId);
661 ASSERT_EQ(nullptr, ret);
662 }
663
664 /**
665 * @tc.name: GetWindowAnimationTargets
666 * @tc.desc: WindowAdapter/GetWindowAnimationTargets
667 * @tc.type: FUNC
668 */
669 HWTEST_F(WindowAdapterTest, GetWindowAnimationTargets, TestSize.Level1)
670 {
671 WindowAdapter windowAdapter;
672 std::vector<uint32_t> missionIds;
673 std::vector<sptr<RSWindowAnimationTarget>> targets;
674 auto ret = windowAdapter.GetWindowAnimationTargets(missionIds, targets);
675 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
676 ASSERT_EQ(WMError::WM_OK, ret);
677 } else {
678 ASSERT_EQ(WMError::WM_ERROR_NO_MEM, ret);
679 }
680 }
681
682 /**
683 * @tc.name: GetMaximizeMode
684 * @tc.desc: WindowAdapter/GetMaximizeMode
685 * @tc.type: FUNC
686 */
687 HWTEST_F(WindowAdapterTest, GetMaximizeMode, TestSize.Level1)
688 {
689 WindowAdapter windowAdapter;
690 auto ret = windowAdapter.InitWMSProxy();
691 ASSERT_EQ(true, ret);
692 windowAdapter.isProxyValid_ = true;
693 ASSERT_EQ(MaximizeMode::MODE_FULL_FILL, windowAdapter.GetMaximizeMode());
694 }
695
696 /**
697 * @tc.name: UpdateSessionAvoidAreaListener
698 * @tc.desc: WindowAdapter/UpdateSessionAvoidAreaListener
699 * @tc.type: FUNC
700 */
701 HWTEST_F(WindowAdapterTest, UpdateSessionAvoidAreaListener, TestSize.Level1)
702 {
703 WindowAdapter windowAdapter;
704 windowAdapter.isProxyValid_ = true;
705 windowAdapter.windowManagerServiceProxy_ = nullptr;
706 int32_t persistentId = 0;
707 bool haveListener = true;
708 auto ret = windowAdapter.UpdateSessionAvoidAreaListener(persistentId, haveListener);
709 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
710 }
711
712 /**
713 * @tc.name: UpdateSessionTouchOutsideListener
714 * @tc.desc: WindowAdapter/UpdateSessionTouchOutsideListener
715 * @tc.type: FUNC
716 */
717 HWTEST_F(WindowAdapterTest, UpdateSessionTouchOutsideListener, TestSize.Level1)
718 {
719 WindowAdapter windowAdapter;
720 windowAdapter.isProxyValid_ = true;
721 windowAdapter.windowManagerServiceProxy_ = nullptr;
722 int32_t persistentId = 0;
723 bool haveListener = true;
724 auto ret = windowAdapter.UpdateSessionTouchOutsideListener(persistentId, haveListener);
725 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
726 }
727
728 /**
729 * @tc.name: SetSessionGravity
730 * @tc.desc: WindowAdapter/SetSessionGravity
731 * @tc.type: FUNC
732 */
733 HWTEST_F(WindowAdapterTest, SetSessionGravity, TestSize.Level1)
734 {
735 WindowAdapter windowAdapter;
736 int32_t persistentId = 0;
737 SessionGravity gravity = SessionGravity::SESSION_GRAVITY_FLOAT;
738 uint32_t percent = 0;
739 auto ret = windowAdapter.SetSessionGravity(persistentId, gravity, percent);
740 ASSERT_EQ(WMError::WM_OK, ret);
741 }
742
743 /**
744 * @tc.name: BindDialogSessionTarget
745 * @tc.desc: WindowAdapter/BindDialogSessionTarget
746 * @tc.type: FUNC
747 */
748 HWTEST_F(WindowAdapterTest, BindDialogSessionTarget, TestSize.Level1)
749 {
750 WindowAdapter windowAdapter;
751 windowAdapter.isProxyValid_ = true;
752 windowAdapter.windowManagerServiceProxy_ = nullptr;
753 uint64_t persistentId = 0;
754 sptr<IRemoteObject> targetToken = nullptr;
755 auto ret = windowAdapter.BindDialogSessionTarget(persistentId, targetToken);
756 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
757 }
758
759 /**
760 * @tc.name: GetHostWindowRect
761 * @tc.desc: WindowAdapter/GetHostWindowRect
762 * @tc.type: FUNC
763 */
764 HWTEST_F(WindowAdapterTest, GetHostWindowRect, TestSize.Level1)
765 {
766 WindowAdapter windowAdapter;
767 int32_t hostWindowId = 0;
768 Rect rect = { 0, 0, 0, 0 };
769 auto ret = windowAdapter.GetHostWindowRect(hostWindowId, rect);
770 ASSERT_EQ(WMError::WM_OK, ret);
771 }
772
773 /**
774 * @tc.name: GetHostGlobalScaledRect
775 * @tc.desc: WindowAdapter/GetHostGlobalScaledRect
776 * @tc.type: FUNC
777 */
778 HWTEST_F(WindowAdapterTest, GetHostGlobalScaledRect, TestSize.Level1)
779 {
780 WindowAdapter windowAdapter;
781 int32_t hostWindowId = 0;
782 Rect rect = { 0, 0, 0, 0 };
783 auto ret = windowAdapter.GetHostGlobalScaledRect(hostWindowId, rect);
784 ASSERT_EQ(WMError::WM_ERROR_INVALID_SESSION, ret);
785 }
786
787 /**
788 * @tc.name: GetWindowModeType
789 * @tc.desc: WindowAdapter/GetWindowModeType
790 * @tc.type: FUNC
791 */
792 HWTEST_F(WindowAdapterTest, GetWindowModeType, TestSize.Level1)
793 {
794 WindowAdapter windowAdapter;
795 WindowModeType windowModeType;
796 ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowAdapter.GetWindowModeType(windowModeType));
797 }
798
799 /**
800 * @tc.name: GetWindowStyleType
801 * @tc.desc: WindowAdapter/GetWindowStyleType
802 * @tc.type: FUNC
803 */
804 HWTEST_F(WindowAdapterTest, GetWindowStyleType, TestSize.Level1)
805 {
806 WindowAdapter windowAdapter;
807 WindowStyleType windowStyleType = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
808 ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowAdapter.GetWindowStyleType(windowStyleType));
809 }
810
811 /**
812 * @tc.name: GetWindowIdsByCoordinate
813 * @tc.desc: WindowAdapter/GetWindowIdsByCoordinate
814 * @tc.type: FUNC
815 */
816 HWTEST_F(WindowAdapterTest, GetWindowIdsByCoordinate, TestSize.Level1)
817 {
818 WindowAdapter windowAdapter;
819 std::vector<int32_t> windowIds;
820 ASSERT_EQ(WMError::WM_OK, windowAdapter.GetWindowIdsByCoordinate(0, 0, 0, 0, windowIds));
821 }
822
823 /**
824 * @tc.name: SetProcessWatermark
825 * @tc.desc: WindowAdapter/SetProcessWatermark
826 * @tc.type: FUNC
827 */
828 HWTEST_F(WindowAdapterTest, SetProcessWatermark, TestSize.Level1)
829 {
830 int32_t pid = 1000;
831 const std::string watermarkName = "SetProcessWatermarkName";
832 bool isEnabled = true;
833 WindowAdapter windowAdapter;
834 windowAdapter.SetProcessWatermark(pid, watermarkName, isEnabled);
835 auto ret = windowAdapter.InitWMSProxy();
836 ASSERT_EQ(true, ret);
837 }
838
839 /**
840 * @tc.name: NotifyScreenshotEvent
841 * @tc.desc: NotifyScreenshotEvent
842 * @tc.type: FUNC
843 */
844 HWTEST_F(WindowAdapterTest, NotifyScreenshotEvent, TestSize.Level1)
845 {
846 ScreenshotEventType type = ScreenshotEventType::SCROLL_SHOT_START;
847 WindowAdapter windowAdapter;
848 auto err = windowAdapter.NotifyScreenshotEvent(type);
849 EXPECT_EQ(err, WMError::WM_OK);
850 auto ret = windowAdapter.InitWMSProxy();
851 EXPECT_EQ(ret, true);
852 }
853
854 /**
855 * @tc.name: UpdateScreenLockStatusForApp
856 * @tc.desc: WindowAdapter/UpdateScreenLockStatusForApp
857 * @tc.type: FUNC
858 */
859 HWTEST_F(WindowAdapterTest, UpdateScreenLockStatusForApp, TestSize.Level1)
860 {
861 WindowAdapter windowAdapter;
862 auto err = windowAdapter.UpdateScreenLockStatusForApp("", true);
863 ASSERT_EQ(err, WMError::WM_OK);
864 auto ret = windowAdapter.InitWMSProxy();
865 ASSERT_EQ(ret, true);
866 }
867
868 /**
869 * @tc.name: CreateAndConnectSpecificSession
870 * @tc.desc: WindowAdapter/CreateAndConnectSpecificSession
871 * @tc.type: FUNC
872 */
873 HWTEST_F(WindowAdapterTest, CreateAndConnectSpecificSession, TestSize.Level1)
874 {
875 WindowAdapter windowAdapter;
876 auto ret = windowAdapter.InitWMSProxy();
877 ASSERT_EQ(ret, true);
878
879 sptr<ISessionStage> sessionStage;
880 sptr<IWindowEventChannel> eventChannel;
881 std::shared_ptr<RSSurfaceNode> node;
882 sptr<WindowSessionProperty> property;
883 sptr<ISession> session;
884 SystemSessionConfig systemConfig;
885 sptr<IRemoteObject> token;
886 int32_t id = 101; // 101 is persistentId
887 windowAdapter.CreateAndConnectSpecificSession(
888 sessionStage, eventChannel, node, property, id, session, systemConfig, token);
889 ASSERT_EQ(session, nullptr);
890 }
891
892 /**
893 * @tc.name: IsPcWindow
894 * @tc.desc: WindowAdapter/IsPcWindow
895 * @tc.type: FUNC
896 */
897 HWTEST_F(WindowAdapterTest, IsPcWindow, TestSize.Level1)
898 {
899 WindowAdapter windowAdapter;
900 bool isPcWindow = false;
901 auto err = windowAdapter.IsPcWindow(isPcWindow);
902 ASSERT_EQ(err, WMError::WM_OK);
903 }
904
905 /**
906 * @tc.name: IsFreeMultiWindowMode
907 * @tc.desc: WindowAdapter/IsFreeMultiWindowMode
908 * @tc.type: FUNC
909 */
910 HWTEST_F(WindowAdapterTest, IsFreeMultiWindowMode, TestSize.Level1)
911 {
912 WindowAdapter windowAdapter;
913 auto ret = windowAdapter.InitWMSProxy();
914 ASSERT_EQ(ret, true);
915
916 auto proxy = windowAdapter.GetWindowManagerServiceProxy();
917 ASSERT_NE(proxy, nullptr);
918 bool proxyIsFreeMultWindow = false;
919 auto proxyRet = proxy->IsFreeMultiWindow(proxyIsFreeMultWindow);
920 ASSERT_EQ(proxyRet, WMError::WM_OK);
921
922 bool isFreeMultiWindow = false;
923 auto err = windowAdapter.IsFreeMultiWindowMode(isFreeMultiWindow);
924
925 ASSERT_EQ(err, WMError::WM_OK);
926 }
927
928 /**
929 * @tc.name: IsPcOrPadFreeMultiWindowMode
930 * @tc.desc: WindowAdapter/IsPcOrPadFreeMultiWindowMode
931 * @tc.type: FUNC
932 */
933 HWTEST_F(WindowAdapterTest, IsPcOrPadFreeMultiWindowMode, TestSize.Level1)
934 {
935 WindowAdapter windowAdapter;
936 bool isPcOrPadFreeMultiWindowMode = false;
937 auto err = windowAdapter.IsPcOrPadFreeMultiWindowMode(isPcOrPadFreeMultiWindowMode);
938 ASSERT_EQ(err, WMError::WM_OK);
939 auto ret = windowAdapter.InitWMSProxy();
940 ASSERT_EQ(ret, true);
941 }
942
943 /**
944 * @tc.name: IsWindowRectAutoSave
945 * @tc.desc: WindowAdapter/IsWindowRectAutoSave
946 * @tc.type: FUNC
947 */
948 HWTEST_F(WindowAdapterTest, IsWindowRectAutoSave, TestSize.Level1)
949 {
950 WindowAdapter windowAdapter;
951 std::string key = "com.example.recposentryEntryAbility";
952 bool enabled = false;
953 int persistentId = 1;
954 auto err = windowAdapter.IsWindowRectAutoSave(key, enabled, persistentId);
955 ASSERT_EQ(err, WMError::WM_ERROR_INVALID_SESSION);
956 auto ret = windowAdapter.InitWMSProxy();
957 ASSERT_EQ(ret, true);
958 }
959
960 /**
961 * @tc.name: SetStartWindowBackgroundColor
962 * @tc.desc: WindowAdapter/SetStartWindowBackgroundColor
963 * @tc.type: FUNC
964 */
965 HWTEST_F(WindowAdapterTest, SetStartWindowBackgroundColor, TestSize.Level1)
966 {
967 WindowAdapter windowAdapter;
968 const std::string& moduleName = "testModuleName";
969 const std::string& abilityName = "testAbilityName";
970 ASSERT_EQ(WMError::WM_ERROR_NO_MEM, windowAdapter.SetStartWindowBackgroundColor(moduleName, abilityName, 0, 0));
971 }
972
973 /**
974 * @tc.name: GetDisplayIdByWindowId
975 * @tc.desc: WindowAdapter/GetDisplayIdByWindowId
976 * @tc.type: FUNC
977 */
978 HWTEST_F(WindowAdapterTest, GetDisplayIdByWindowId, TestSize.Level1)
979 {
980 WindowAdapter windowAdapter;
981 const std::vector<uint64_t> windowIds = { 1, 2 };
982 std::unordered_map<uint64_t, DisplayId> windowDisplayIdMap;
983 auto err = windowAdapter.GetDisplayIdByWindowId(windowIds, windowDisplayIdMap);
984 ASSERT_EQ(err, WMError::WM_OK);
985 }
986
987 /**
988 * @tc.name: SetGlobalDragResizeType
989 * @tc.desc: WindowAdapter/SetGlobalDragResizeType
990 * @tc.type: FUNC
991 */
992 HWTEST_F(WindowAdapterTest, SetGlobalDragResizeType, TestSize.Level1)
993 {
994 WindowAdapter windowAdapter;
995 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
996 auto err = windowAdapter.SetGlobalDragResizeType(dragResizeType);
997 ASSERT_EQ(err, WMError::WM_OK);
998 }
999
1000 /**
1001 * @tc.name: GetGlobalDragResizeType
1002 * @tc.desc: WindowAdapter/GetGlobalDragResizeType
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(WindowAdapterTest, GetGlobalDragResizeType, TestSize.Level1)
1006 {
1007 WindowAdapter windowAdapter;
1008 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1009 auto err = windowAdapter.GetGlobalDragResizeType(dragResizeType);
1010 ASSERT_EQ(err, WMError::WM_OK);
1011 }
1012
1013 /**
1014 * @tc.name: SetAppDragResizeType
1015 * @tc.desc: WindowAdapter/SetAppDragResizeType
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(WindowAdapterTest, SetAppDragResizeType, TestSize.Level1)
1019 {
1020 WindowAdapter windowAdapter;
1021 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1022 const std::string bundleName = "test";
1023 auto err = windowAdapter.SetAppDragResizeType(bundleName, dragResizeType);
1024 ASSERT_EQ(err, WMError::WM_OK);
1025 }
1026
1027 /**
1028 * @tc.name: GetAppDragResizeType
1029 * @tc.desc: WindowAdapter/GetAppDragResizeType
1030 * @tc.type: FUNC
1031 */
1032 HWTEST_F(WindowAdapterTest, GetAppDragResizeType, TestSize.Level1)
1033 {
1034 WindowAdapter windowAdapter;
1035 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1036 const std::string bundleName = "test";
1037 auto err = windowAdapter.GetAppDragResizeType(bundleName, dragResizeType);
1038 ASSERT_EQ(err, WMError::WM_OK);
1039 }
1040
1041 /**
1042 * @tc.name: SetAppKeyFramePolicy
1043 * @tc.desc: WindowAdapter/SetAppKeyFramePolicy
1044 * @tc.type: FUNC
1045 */
1046 HWTEST_F(WindowAdapterTest, SetAppKeyFramePolicy, TestSize.Level1)
1047 {
1048 WindowAdapter windowAdapter;
1049 const std::string bundleName = "test";
1050 KeyFramePolicy keyFramePolicy;
1051 keyFramePolicy.dragResizeType_ = DragResizeType::RESIZE_KEY_FRAME;
1052 auto err = windowAdapter.SetAppKeyFramePolicy(bundleName, keyFramePolicy);
1053 ASSERT_EQ(err, WMError::WM_OK);
1054 }
1055
1056 /**
1057 * @tc.name: SetParentWindow
1058 * @tc.desc: WindowAdapter/SetParentWindow
1059 * @tc.type: FUNC
1060 */
1061 HWTEST_F(WindowAdapterTest, SetParentWindow, TestSize.Level1)
1062 {
1063 WindowAdapter windowAdapter;
1064 int32_t subWindowId = 1;
1065 int32_t newParentWindowId = 2;
1066 auto err = windowAdapter.SetParentWindow(subWindowId, newParentWindowId);
1067 ASSERT_EQ(err, WMError::WM_ERROR_INVALID_WINDOW);
1068 }
1069
1070 /**
1071 * @tc.name: NotifyWatchGestureConsumeResult
1072 * @tc.desc: WindowAdapter/NotifyWatchGestureConsumeResult
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F(WindowAdapterTest, NotifyWatchGestureConsumeResult, TestSize.Level1)
1076 {
1077 WindowAdapter windowAdapter;
1078 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, windowAdapter.NotifyWatchGestureConsumeResult(0, true));
1079 }
1080
1081 /**
1082 * @tc.name: NotifyWatchFocusActiveChange
1083 * @tc.desc: WindowAdapter/NotifyWatchFocusActiveChange
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(WindowAdapterTest, NotifyWatchFocusActiveChange, TestSize.Level1)
1087 {
1088 WindowAdapter windowAdapter;
1089 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, windowAdapter.NotifyWatchFocusActiveChange(true));
1090 }
1091
1092 /**
1093 * @tc.name: MinimizeByWindowId
1094 * @tc.desc: WindowAdapter/MinimizeByWindowId
1095 * @tc.type: FUNC
1096 */
1097 HWTEST_F(WindowAdapterTest, MinimizeByWindowId, TestSize.Level1)
1098 {
1099 WindowAdapter windowAdapter;
1100 std::vector<int32_t> windowIds;
1101 auto err = windowAdapter.MinimizeByWindowId(windowIds);
1102 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, err);
1103 auto ret = windowAdapter.InitWMSProxy();
1104 ASSERT_EQ(ret, true);
1105 }
1106
1107 /**
1108 * @tc.name: ListWindowInfo01
1109 * @tc.desc: WindowAdapter/ListWindowInfo
1110 * @tc.type: FUNC
1111 */
1112 HWTEST_F(WindowAdapterTest, ListWindowInfo01, Function | SmallTest | Level2)
1113 {
1114 WindowAdapter windowAdapter;
1115 WindowInfoOption windowInfoOption;
1116 std::vector<sptr<WindowInfo>> infos;
1117 auto err = windowAdapter.ListWindowInfo(windowInfoOption, infos);
1118 ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, err);
1119 auto ret = windowAdapter.InitWMSProxy();
1120 ASSERT_EQ(ret, true);
1121 }
1122
1123 /**
1124 * @tc.name: RegisterWindowPropertyChangeAgent01
1125 * @tc.desc: WindowAdapter/RegisterWindowPropertyChangeAgent
1126 * @tc.type: FUNC
1127 */
1128 HWTEST_F(WindowAdapterTest, RegisterWindowPropertyChangeAgent01, Function | SmallTest | Level2)
1129 {
1130 WindowAdapter windowAdapter;
1131 WindowInfoOption windowInfoOption;
1132 WindowInfoKey windowInfoKey = WindowInfoKey::NONE;
1133 uint32_t interestInfo = 0;
1134 sptr<IWindowManagerAgent> windowManagerAgent;
1135 auto err = windowAdapter.RegisterWindowPropertyChangeAgent(windowInfoKey, interestInfo, windowManagerAgent);
1136 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, err);
1137 auto ret = windowAdapter.InitWMSProxy();
1138 EXPECT_EQ(ret, true);
1139 }
1140
1141 /**
1142 * @tc.name: UnregisterWindowPropertyChangeAgent01
1143 * @tc.desc: WindowAdapter/UnregisterWindowPropertyChangeAgent
1144 * @tc.type: FUNC
1145 */
1146 HWTEST_F(WindowAdapterTest, UnregisterWindowPropertyChangeAgent01, Function | SmallTest | Level2)
1147 {
1148 WindowAdapter windowAdapter;
1149 WindowInfoOption windowInfoOption;
1150 WindowInfoKey windowInfoKey = WindowInfoKey::NONE;
1151 uint32_t interestInfo = 0;
1152 sptr<IWindowManagerAgent> windowManagerAgent;
1153 auto err = windowAdapter.UnregisterWindowPropertyChangeAgent(windowInfoKey, interestInfo, windowManagerAgent);
1154 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, err);
1155 auto ret = windowAdapter.InitWMSProxy();
1156 EXPECT_EQ(ret, true);
1157 }
1158
1159 /**
1160 * @tc.name: CreateUIEffectController
1161 * @tc.desc: WindowAdapter/CreateUIEffectController
1162 * @tc.type: FUNC
1163 */
1164 HWTEST_F(WindowAdapterTest, CreateUIEffectController, Function | SmallTest | Level2)
1165 {
1166 WindowAdapter windowAdapter;
1167 sptr<UIEffectControllerClient> client = sptr<UIEffectControllerClient>::MakeSptr();
1168 sptr<IUIEffectController> controller;
1169 int32_t controllerId = 0;
1170 auto err = windowAdapter.CreateUIEffectController(client, controller, controllerId);
1171 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, err);
1172 auto ret = windowAdapter.InitWMSProxy();
1173 EXPECT_EQ(ret, true);
1174 windowAdapter.CreateUIEffectController(client, controller, controllerId);
1175 }
1176
1177 /**
1178 * @tc.name: AddSessionBlackList01
1179 * @tc.desc: WindowAdapter/AddSessionBlackList
1180 * @tc.type: FUNC
1181 */
1182 HWTEST_F(WindowAdapterTest, AddSessionBlackList01, Function | SmallTest | Level2)
1183 {
1184 WindowAdapter windowAdapter;
1185 std::unordered_set<std::string> bundleNames;
1186 std::unordered_set<std::string> privacyWindowTags;
1187 sptr<IWindowManagerAgent> windowManagerAgent;
1188 auto err = windowAdapter.AddSessionBlackList(bundleNames, privacyWindowTags);
1189 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, err);
1190 auto ret = windowAdapter.InitWMSProxy();
1191 EXPECT_EQ(ret, true);
1192 }
1193
1194 /**
1195 * @tc.name: RemoveSessionBlackList01
1196 * @tc.desc: WindowAdapter/RemoveSessionBlackList
1197 * @tc.type: FUNC
1198 */
1199 HWTEST_F(WindowAdapterTest, RemoveSessionBlackList01, Function | SmallTest | Level2)
1200 {
1201 WindowAdapter windowAdapter;
1202 std::unordered_set<std::string> bundleNames;
1203 std::unordered_set<std::string> privacyWindowTags;
1204 sptr<IWindowManagerAgent> windowManagerAgent;
1205 auto err = windowAdapter.RemoveSessionBlackList(bundleNames, privacyWindowTags);
1206 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, err);
1207 auto ret = windowAdapter.InitWMSProxy();
1208 EXPECT_EQ(ret, true);
1209 }
1210
1211 /**
1212 * @tc.name: GetPiPSettingSwitchStatus
1213 * @tc.desc: WindowAdapter/GetPiPSettingSwitchStatus
1214 * @tc.type: FUNC
1215 */
1216 HWTEST_F(WindowAdapterTest, GetPiPSettingSwitchStatus, TestSize.Level1)
1217 {
1218 WindowAdapter windowAdapter;
1219 bool switchStatus = false;
1220 auto err = windowAdapter.GetPiPSettingSwitchStatus(switchStatus);
1221 ASSERT_EQ(WMError::WM_OK, err);
1222 }
1223
1224 /**
1225 * @tc.name: UseImplicitAnimation
1226 * @tc.desc: WindowAdapter/UseImplicitAnimation
1227 * @tc.type: FUNC
1228 */
1229 HWTEST_F(WindowAdapterTest, UseImplicitAnimation, TestSize.Level1)
1230 {
1231 WindowAdapter windowAdapter;
1232 ASSERT_EQ(WMError::WM_ERROR_INVALID_SESSION, windowAdapter.UseImplicitAnimation(0, true));
1233 }
1234 } // namespace
1235 } // namespace Rosen
1236 } // namespace OHOS