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 "starting_window.h"
21 #include "window_transition_info.h"
22 #include "window_property.h"
23 #include "window_agent.h"
24 #include "window_adapter.h"
25 #include "scene_board_judgement.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Rosen {
32 constexpr uint32_t WINDOW_ID = 1000;
33 class WindowAdapterTest : public testing::Test {
34 public:
35     static void SetUpTestCase();
36     static void TearDownTestCase();
37     void SetUp() override;
38     void TearDown() override;
39 };
40 
SetUpTestCase()41 void WindowAdapterTest::SetUpTestCase()
42 {
43 }
44 
TearDownTestCase()45 void WindowAdapterTest::TearDownTestCase()
46 {
47 }
48 
SetUp()49 void WindowAdapterTest::SetUp()
50 {
51 }
52 
TearDown()53 void WindowAdapterTest::TearDown()
54 {
55 }
56 
57 namespace {
58 /**
59  * @tc.name: AddWindow
60  * @tc.desc: WindowAdapter/AddWindow
61  * @tc.type: FUNC
62  */
63 HWTEST_F(WindowAdapterTest, AddWindow, Function | SmallTest | Level2)
64 {
65     sptr<WindowProperty> windowProperty = nullptr;
66     WindowAdapter windowAdapter;
67 
68     windowAdapter.AddWindow(windowProperty);
69     auto ret = windowAdapter.InitWMSProxy();
70     ASSERT_EQ(true, ret);
71 }
72 
73 /**
74  * @tc.name: RemoveWindow
75  * @tc.desc: WindowAdapter/RemoveWindow
76  * @tc.type: FUNC
77  */
78 HWTEST_F(WindowAdapterTest, RemoveWindow, Function | SmallTest | Level2)
79 {
80     uint32_t windowId = 0;
81     bool isFromInnerkits = false;
82     WindowAdapter windowAdapter;
83 
84     windowAdapter.RemoveWindow(windowId, isFromInnerkits);
85     auto ret = windowAdapter.InitWMSProxy();
86     ASSERT_EQ(true, ret);
87 }
88 
89 /**
90  * @tc.name: RequestFocus
91  * @tc.desc: WindowAdapter/RequestFocus
92  * @tc.type: FUNC
93  */
94 HWTEST_F(WindowAdapterTest, RequestFocus, Function | SmallTest | Level2)
95 {
96     uint32_t windowId = 0;
97     WindowAdapter windowAdapter;
98 
99     windowAdapter.RequestFocus(windowId);
100     auto ret = windowAdapter.InitWMSProxy();
101     ASSERT_EQ(true, ret);
102 }
103 
104 /**
105  * @tc.name: GetUIContentRemoteObj
106  * @tc.desc: WindowAdapter/GetUIContentRemoteObj
107  * @tc.type: FUNC
108  */
109 HWTEST_F(WindowAdapterTest, GetUIContentRemoteObj, Function | SmallTest | Level2)
110 {
111     WindowAdapter windowAdapter;
112     windowAdapter.isProxyValid_ = true;
113     windowAdapter.windowManagerServiceProxy_ = nullptr;
114     sptr<IRemoteObject> remoteObj;
115     auto ret = windowAdapter.GetUIContentRemoteObj(WINDOW_ID, remoteObj);
116     ASSERT_EQ(ret, WMError::WM_ERROR_SAMGR);
117 }
118 
119 /**
120  * @tc.name: CheckWindowId
121  * @tc.desc: WindowAdapter/CheckWindowId
122  * @tc.type: FUNC
123  */
124 HWTEST_F(WindowAdapterTest, CheckWindowId, Function | SmallTest | Level2)
125 {
126     int32_t windowId = 0;
127     int32_t pid = 0;
128     WindowAdapter windowAdapter;
129 
130     windowAdapter.CheckWindowId(windowId, pid);
131     auto ret = windowAdapter.InitWMSProxy();
132     ASSERT_EQ(true, ret);
133 }
134 
135 /**
136  * @tc.name: SetWindowAnimationController
137  * @tc.desc: WindowAdapter/SetWindowAnimationController
138  * @tc.type: FUNC
139  */
140 HWTEST_F(WindowAdapterTest, SetWindowAnimationController, Function | SmallTest | Level2)
141 {
142     sptr<RSIWindowAnimationController> controller = nullptr;
143     WindowAdapter windowAdapter;
144 
145     windowAdapter.SetWindowAnimationController(controller);
146     auto ret = windowAdapter.InitWMSProxy();
147     ASSERT_EQ(true, ret);
148 }
149 
150 /**
151  * @tc.name: GetAvoidAreaByType
152  * @tc.desc: WindowAdapter/GetAvoidAreaByType
153  * @tc.type: FUNC
154  */
155 HWTEST_F(WindowAdapterTest, GetAvoidAreaByType, Function | SmallTest | Level2)
156 {
157     uint32_t windowId = 0;
158     AvoidAreaType type = AvoidAreaType::TYPE_CUTOUT;
159     AvoidArea avoidArea;
160     WindowAdapter windowAdapter;
161 
162     windowAdapter.GetAvoidAreaByType(windowId, type, avoidArea);
163     auto ret = windowAdapter.InitWMSProxy();
164     ASSERT_EQ(true, ret);
165 }
166 
167 /**
168  * @tc.name: NotifyServerReadyToMoveOrDrag
169  * @tc.desc: WindowAdapter/NotifyServerReadyToMoveOrDrag
170  * @tc.type: FUNC
171  */
172 HWTEST_F(WindowAdapterTest, NotifyServerReadyToMoveOrDrag, Function | SmallTest | Level2)
173 {
174     uint32_t windowId = 0;
175     sptr<WindowProperty> windowProperty = nullptr;
176     sptr<MoveDragProperty> moveDragProperty = nullptr;
177     WindowAdapter windowAdapter;
178 
179     windowAdapter.NotifyServerReadyToMoveOrDrag(windowId, windowProperty, moveDragProperty);
180     auto ret = windowAdapter.InitWMSProxy();
181     ASSERT_EQ(true, ret);
182 }
183 
184 /**
185  * @tc.name: ProcessPointDown
186  * @tc.desc: WindowAdapter/ProcessPointDown
187  * @tc.type: FUNC
188  */
189 HWTEST_F(WindowAdapterTest, ProcessPointDown, Function | SmallTest | Level2)
190 {
191     uint32_t windowId = 0;
192     bool isPointDown = false;
193     WindowAdapter windowAdapter;
194 
195     windowAdapter.ProcessPointDown(windowId, isPointDown);
196     windowAdapter.ProcessPointUp(windowId);
197     auto ret = windowAdapter.InitWMSProxy();
198     ASSERT_EQ(true, ret);
199 }
200 
201 /**
202  * @tc.name: ToggleShownStateForAllAppWindows
203  * @tc.desc: WindowAdapter/ToggleShownStateForAllAppWindows
204  * @tc.type: FUNC
205  */
206 HWTEST_F(WindowAdapterTest, ToggleShownStateForAllAppWindows, Function | SmallTest | Level2)
207 {
208     WindowAdapter windowAdapter;
209 
210     windowAdapter.ToggleShownStateForAllAppWindows();
211     auto ret = windowAdapter.InitWMSProxy();
212     ASSERT_EQ(true, ret);
213 }
214 
215 /**
216  * @tc.name: GetSnapshotByWindowId
217  * @tc.desc: WindowAdapter/GetSnapshotByWindowId
218  * @tc.type: FUNC
219  */
220 HWTEST_F(WindowAdapterTest, GetSnapshotByWindowId, Function | SmallTest | Level2)
221 {
222     WindowAdapter windowAdapter;
223     int32_t persistentId = -1;
224     std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
225     windowAdapter.GetSnapshotByWindowId(persistentId, pixelMap);
226     auto ret = windowAdapter.InitWMSProxy();
227     ASSERT_EQ(true, ret);
228 }
229 
230 /**
231  * @tc.name: InitWMSProxy
232  * @tc.desc: WindowAdapter/InitWMSProxy
233  * @tc.type: FUNC
234  */
235 HWTEST_F(WindowAdapterTest, InitWMSProxy, Function | SmallTest | Level2)
236 {
237     WindowAdapter windowAdapter;
238     auto ret = windowAdapter.InitWMSProxy();
239     ASSERT_EQ(true, ret);
240 }
241 
242 /**
243  * @tc.name: GetUnreliableWindowInfo
244  * @tc.desc: WindowAdapter/GetUnreliableWindowInfo
245  * @tc.type: FUNC
246  */
247 HWTEST_F(WindowAdapterTest, GetUnreliableWindowInfo, Function | SmallTest | Level2)
248 {
249     int32_t windowId = 0;
250     std::vector<sptr<UnreliableWindowInfo>> infos;
251     WindowAdapter windowAdapter;
252     windowAdapter.GetUnreliableWindowInfo(windowId, infos);
253     auto ret = windowAdapter.InitWMSProxy();
254     ASSERT_EQ(true, ret);
255 }
256 
257 /**
258  * @tc.name: DestroyAndDisconnectSpecificSession
259  * @tc.desc: WindowAdapter/DestroyAndDisconnectSpecificSession
260  * @tc.type: FUNC
261  */
262 HWTEST_F(WindowAdapterTest, DestroyAndDisconnectSpecificSession, Function | SmallTest | Level2)
263 {
264     uint32_t persistentId = 0;
265     WindowAdapter windowAdapter;
266     windowAdapter.DestroyAndDisconnectSpecificSession(persistentId);
267     auto ret = windowAdapter.InitWMSProxy();
268     ASSERT_EQ(true, ret);
269 }
270 
271 /**
272  * @tc.name: DestroyAndDisconnectSpecificSessionWithDetachCallback
273  * @tc.desc: WindowAdapter/DestroyAndDisconnectSpecificSessionWithDetachCallback
274  * @tc.type: FUNC
275  */
276 HWTEST_F(WindowAdapterTest, DestroyAndDisconnectSpecificSessionWithDetachCallback, Function | SmallTest | Level2)
277 {
278     uint32_t persistentId = 0;
279     WindowAdapter windowAdapter;
280     windowAdapter.DestroyAndDisconnectSpecificSessionWithDetachCallback(persistentId, nullptr);
281     auto ret = windowAdapter.InitWMSProxy();
282     ASSERT_EQ(true, ret);
283 }
284 
285 /**
286  * @tc.name: UpdateModalExtensionRect
287  * @tc.desc: WindowAdapter/UpdateModalExtensionRect
288  * @tc.type: FUNC
289  */
290 HWTEST_F(WindowAdapterTest, UpdateModalExtensionRect, Function | SmallTest | Level2)
291 {
292     WindowAdapter windowAdapter;
293     Rect rect { 1, 2, 3, 4 };
294     sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
295     ASSERT_NE(token, nullptr);
296     windowAdapter.UpdateModalExtensionRect(token, rect);
297     windowAdapter.UpdateModalExtensionRect(nullptr, rect);
298     auto ret = windowAdapter.InitWMSProxy();
299     EXPECT_TRUE(ret);
300 }
301 
302 /**
303  * @tc.name: ProcessModalExtensionPointDown
304  * @tc.desc: WindowAdapter/ProcessModalExtensionPointDown
305  * @tc.type: FUNC
306  */
307 HWTEST_F(WindowAdapterTest, ProcessModalExtensionPointDown, Function | SmallTest | Level2)
308 {
309     WindowAdapter windowAdapter;
310     sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
311     ASSERT_NE(token, nullptr);
312     windowAdapter.ProcessModalExtensionPointDown(token, 0, 0);
313     windowAdapter.ProcessModalExtensionPointDown(nullptr, 0, 0);
314     auto ret = windowAdapter.InitWMSProxy();
315     EXPECT_TRUE(ret);
316 }
317 
318 /**
319  * @tc.name: AddExtensionWindowStageToSCB
320  * @tc.desc: WindowAdapter/AddExtensionWindowStageToSCB
321  * @tc.type: FUNC
322  */
323 HWTEST_F(WindowAdapterTest, AddExtensionWindowStageToSCB, Function | SmallTest | Level2)
324 {
325     WindowAdapter windowAdapter;
326     windowAdapter.AddExtensionWindowStageToSCB(nullptr, nullptr, 0);
327     auto ret = windowAdapter.InitWMSProxy();
328     EXPECT_TRUE(ret);
329 }
330 
331 /**
332  * @tc.name: RemoveExtensionWindowStageFromSCB
333  * @tc.desc: WindowAdapter/RemoveExtensionWindowStageFromSCB
334  * @tc.type: FUNC
335  */
336 HWTEST_F(WindowAdapterTest, RemoveExtensionWindowStageFromSCB, Function | SmallTest | Level2)
337 {
338     WindowAdapter windowAdapter;
339     windowAdapter.RemoveExtensionWindowStageFromSCB(nullptr, nullptr);
340     auto ret = windowAdapter.InitWMSProxy();
341     EXPECT_TRUE(ret);
342 }
343 
344 /**
345  * @tc.name: AddOrRemoveSecureSession
346  * @tc.desc: WindowAdapter/AddOrRemoveSecureSession
347  * @tc.type: FUNC
348  */
349 HWTEST_F(WindowAdapterTest, AddOrRemoveSecureSession, Function | SmallTest | Level2)
350 {
351     int32_t persistentId = 0;
352     WindowAdapter windowAdapter;
353     windowAdapter.AddOrRemoveSecureSession(persistentId, true);
354     auto ret = windowAdapter.InitWMSProxy();
355     ASSERT_EQ(true, ret);
356 }
357 
358 /**
359  * @tc.name: UpdateExtWindowFlags
360  * @tc.desc: WindowAdapter/UpdateExtWindowFlags
361  * @tc.type: FUNC
362  */
363 HWTEST_F(WindowAdapterTest, UpdateExtWindowFlags, Function | SmallTest | Level2)
364 {
365     WindowAdapter windowAdapter;
366     sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
367     ASSERT_NE(token, nullptr);
368     windowAdapter.UpdateExtWindowFlags(token, 7, 7);
369     windowAdapter.UpdateExtWindowFlags(nullptr, 7, 7);
370     auto ret = windowAdapter.InitWMSProxy();
371     ASSERT_EQ(true, ret);
372 }
373 
374 /**
375  * @tc.name: GetVisibilityWindowInfo
376  * @tc.desc: WindowAdapter/GetVisibilityWindowInfo
377  * @tc.type: FUNC
378  */
379 HWTEST_F(WindowAdapterTest, GetVisibilityWindowInfo, Function | SmallTest | Level2)
380 {
381     WindowAdapter windowAdapter;
382     std::vector<sptr<WindowVisibilityInfo>> infos;
383     auto ret = windowAdapter.GetVisibilityWindowInfo(infos);
384     windowAdapter.WindowManagerAndSessionRecover();
385     ASSERT_EQ(WMError::WM_OK, ret);
386 }
387 
388 /**
389  * @tc.name: ReregisterWindowManagerAgent
390  * @tc.desc: WindowAdapter/ReregisterWindowManagerAgent
391  * @tc.type: FUNC
392  */
393 HWTEST_F(WindowAdapterTest, ReregisterWindowManagerAgent, Function | SmallTest | Level2)
394 {
395     WindowAdapter windowAdapter;
396     auto displayId = 0;
397     ModeChangeHotZones hotZones;
398     auto ret = windowAdapter.GetModeChangeHotZones(displayId, hotZones);
399     windowAdapter.ReregisterWindowManagerAgent();
400     ASSERT_EQ(WMError::WM_OK, ret);
401 }
402 
403 /**
404  * @tc.name: UpdateProperty
405  * @tc.desc: WindowAdapter/UpdateProperty
406  * @tc.type: FUNC
407  */
408 HWTEST_F(WindowAdapterTest, UpdateProperty, Function | SmallTest | Level2)
409 {
410     WindowAdapter windowAdapter;
411     sptr<WindowProperty> windowProperty = sptr<WindowProperty>::MakeSptr();
412     PropertyChangeAction action = PropertyChangeAction::ACTION_UPDATE_RECT;
413     auto ret = windowAdapter.UpdateProperty(windowProperty, action);
414     windowAdapter.OnUserSwitch();
415     windowAdapter.ClearWindowAdapter();
416     ASSERT_EQ(WMError::WM_OK, ret);
417 }
418 
419 /**
420  * @tc.name: SetWindowGravity
421  * @tc.desc: WindowAdapter/SetWindowGravity
422  * @tc.type: FUNC
423  */
424 HWTEST_F(WindowAdapterTest, SetWindowGravity, Function | SmallTest | Level2)
425 {
426     WindowAdapter windowAdapter;
427     windowAdapter.isProxyValid_ = true;
428     windowAdapter.windowManagerServiceProxy_ = nullptr;
429     uint32_t windowId = 0;
430     WindowGravity gravity = WindowGravity::WINDOW_GRAVITY_FLOAT;
431     uint32_t percent = 0;
432     auto ret = windowAdapter.SetWindowGravity(windowId, gravity, percent);
433     ASSERT_EQ(WMError::WM_ERROR_SAMGR, ret);
434 }
435 
436 /**
437  * @tc.name: NotifyWindowTransition
438  * @tc.desc: WindowAdapter/NotifyWindowTransition
439  * @tc.type: FUNC
440  */
441 HWTEST_F(WindowAdapterTest, NotifyWindowTransition, Function | SmallTest | Level2)
442 {
443     WindowAdapter windowAdapter;
444     windowAdapter.isProxyValid_ = true;
445     windowAdapter.windowManagerServiceProxy_ = nullptr;
446     sptr<WindowTransitionInfo> from = nullptr;
447     sptr<WindowTransitionInfo> to = nullptr;
448     auto ret = windowAdapter.NotifyWindowTransition(from, to);
449     ASSERT_EQ(WMError::WM_ERROR_SAMGR, ret);
450 }
451 
452 /**
453  * @tc.name: RaiseToAppTop
454  * @tc.desc: WindowAdapter/RaiseToAppTop
455  * @tc.type: FUNC
456  */
457 HWTEST_F(WindowAdapterTest, RaiseToAppTop, Function | SmallTest | Level2)
458 {
459     WindowAdapter windowAdapter;
460     uint32_t windowId = 0;
461     auto ret = windowAdapter.RaiseToAppTop(windowId);
462     std::shared_ptr<MMI::KeyEvent> event = nullptr;
463     windowAdapter.DispatchKeyEvent(windowId, event);
464     ASSERT_EQ(WMError::WM_OK, ret);
465 }
466 
467 /**
468  * @tc.name: GetSnapshot
469  * @tc.desc: WindowAdapter/GetSnapshot
470  * @tc.type: FUNC
471  */
472 HWTEST_F(WindowAdapterTest, GetSnapshot, Function | SmallTest | Level2)
473 {
474     WindowAdapter windowAdapter;
475     int32_t windowId = 0;
476     auto ret = windowAdapter.GetSnapshot(windowId);
477     ASSERT_EQ(nullptr, ret);
478 }
479 
480 /**
481  * @tc.name: GetWindowAnimationTargets
482  * @tc.desc: WindowAdapter/GetWindowAnimationTargets
483  * @tc.type: FUNC
484  */
485 HWTEST_F(WindowAdapterTest, GetWindowAnimationTargets, Function | SmallTest | Level2)
486 {
487     WindowAdapter windowAdapter;
488     std::vector<uint32_t> missionIds;
489     std::vector<sptr<RSWindowAnimationTarget>> targets;
490     auto ret = windowAdapter.GetWindowAnimationTargets(missionIds, targets);
491     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
492         ASSERT_EQ(WMError::WM_OK, ret);
493     } else {
494         ASSERT_EQ(WMError::WM_ERROR_NO_MEM, ret);
495     }
496 }
497 
498 /**
499  * @tc.name: GetMaximizeMode
500  * @tc.desc: WindowAdapter/GetMaximizeMode
501  * @tc.type: FUNC
502  */
503 HWTEST_F(WindowAdapterTest, GetMaximizeMode, Function | SmallTest | Level2)
504 {
505     WindowAdapter windowAdapter;
506     windowAdapter.isProxyValid_ = true;
507     windowAdapter.windowManagerServiceProxy_ = nullptr;
508     auto ret = windowAdapter.GetMaximizeMode();
509     ASSERT_EQ(MaximizeMode::MODE_FULL_FILL, ret);
510 }
511 
512 /**
513  * @tc.name: UpdateSessionAvoidAreaListener
514  * @tc.desc: WindowAdapter/UpdateSessionAvoidAreaListener
515  * @tc.type: FUNC
516  */
517 HWTEST_F(WindowAdapterTest, UpdateSessionAvoidAreaListener, Function | SmallTest | Level2)
518 {
519     WindowAdapter windowAdapter;
520     windowAdapter.isProxyValid_ = true;
521     windowAdapter.windowManagerServiceProxy_ = nullptr;
522     int32_t persistentId = 0;
523     bool haveListener = true;
524     auto ret = windowAdapter.UpdateSessionAvoidAreaListener(persistentId, haveListener);
525     ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
526 }
527 
528 /**
529  * @tc.name: UpdateSessionTouchOutsideListener
530  * @tc.desc: WindowAdapter/UpdateSessionTouchOutsideListener
531  * @tc.type: FUNC
532  */
533 HWTEST_F(WindowAdapterTest, UpdateSessionTouchOutsideListener, Function | SmallTest | Level2)
534 {
535     WindowAdapter windowAdapter;
536     windowAdapter.isProxyValid_ = true;
537     windowAdapter.windowManagerServiceProxy_ = nullptr;
538     int32_t persistentId = 0;
539     bool haveListener = true;
540     auto ret = windowAdapter.UpdateSessionTouchOutsideListener(persistentId, haveListener);
541     ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
542 }
543 
544 /**
545  * @tc.name: SetSessionGravity
546  * @tc.desc: WindowAdapter/SetSessionGravity
547  * @tc.type: FUNC
548  */
549 HWTEST_F(WindowAdapterTest, SetSessionGravity, Function | SmallTest | Level2)
550 {
551     WindowAdapter windowAdapter;
552     int32_t persistentId = 0;
553     SessionGravity gravity = SessionGravity::SESSION_GRAVITY_FLOAT;
554     uint32_t percent = 0;
555     auto ret = windowAdapter.SetSessionGravity(persistentId, gravity, percent);
556     ASSERT_EQ(WMError::WM_OK, ret);
557 }
558 
559 /**
560  * @tc.name: BindDialogSessionTarget
561  * @tc.desc: WindowAdapter/BindDialogSessionTarget
562  * @tc.type: FUNC
563  */
564 HWTEST_F(WindowAdapterTest, BindDialogSessionTarget, Function | SmallTest | Level2)
565 {
566     WindowAdapter windowAdapter;
567     windowAdapter.isProxyValid_ = true;
568     windowAdapter.windowManagerServiceProxy_ = nullptr;
569     uint64_t persistentId = 0;
570     sptr<IRemoteObject> targetToken = nullptr;
571     auto ret = windowAdapter.BindDialogSessionTarget(persistentId, targetToken);
572     ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
573 }
574 
575 /**
576  * @tc.name: GetHostWindowRect
577  * @tc.desc: WindowAdapter/GetHostWindowRect
578  * @tc.type: FUNC
579  */
580 HWTEST_F(WindowAdapterTest, GetHostWindowRect, Function | SmallTest | Level2)
581 {
582     WindowAdapter windowAdapter;
583     int32_t hostWindowId = 0;
584     Rect rect = {0, 0, 0, 0};
585     auto ret = windowAdapter.GetHostWindowRect(hostWindowId, rect);
586     ASSERT_EQ(WMError::WM_OK, ret);
587 }
588 
589 /**
590  * @tc.name: GetWindowStyleType
591  * @tc.desc: WindowAdapter/GetWindowStyleType
592  * @tc.type: FUNC
593  */
594 HWTEST_F(WindowAdapterTest, GetWindowStyleType, Function | SmallTest | Level2)
595 {
596     WindowAdapter windowAdapter;
597     WindowStyleType windowStyleType = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
598     windowAdapter.GetWindowStyleType(windowStyleType);
599     ASSERT_EQ(Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT, windowStyleType);
600 }
601 
602 /**
603  * @tc.name: ReleaseForegroundSessionScreenLock
604  * @tc.desc: WindowAdapter/ReleaseForegroundSessionScreenLock
605  * @tc.type: FUNC
606  */
607 HWTEST_F(WindowAdapterTest, ReleaseForegroundSessionScreenLock, Function | SmallTest | Level2)
608 {
609     WindowAdapter windowAdapter;
610     auto err = windowAdapter.ReleaseForegroundSessionScreenLock();
611     ASSERT_EQ(err, WMError::WM_OK);
612     auto ret = windowAdapter.InitWMSProxy();
613     ASSERT_EQ(ret, true);
614 }
615 
616 /**
617  * @tc.name: IsPcWindow
618  * @tc.desc: WindowAdapter/IsPcWindow
619  * @tc.type: FUNC
620  */
621 HWTEST_F(WindowAdapterTest, IsPcWindow, Function | SmallTest | Level2)
622 {
623     WindowAdapter windowAdapter;
624     bool isPcWindow = false;
625     auto err = windowAdapter.IsPcWindow(isPcWindow);
626     ASSERT_EQ(err, WMError::WM_OK);
627 }
628 
629 /**
630  * @tc.name: IsWindowRectAutoSave
631  * @tc.desc: WindowAdapter/IsWindowRectAutoSave
632  * @tc.type: FUNC
633  */
634 HWTEST_F(WindowAdapterTest, IsWindowRectAutoSave, Function | SmallTest | Level2)
635 {
636     WindowAdapter windowAdapter;
637     std::string key = "com.example.recposentryEntryAbility";
638     bool enabled = false;
639     auto err = windowAdapter.IsWindowRectAutoSave(key, enabled);
640     ASSERT_EQ(err, WMError::WM_OK);
641     auto ret = windowAdapter.InitWMSProxy();
642     ASSERT_EQ(ret, true);
643 }
644 
645 /**
646  * @tc.name: GetDisplayIdByWindowId
647  * @tc.desc: WindowAdapter/GetDisplayIdByWindowId
648  * @tc.type: FUNC
649  */
650 HWTEST_F(WindowAdapterTest, GetDisplayIdByWindowId, Function | SmallTest | Level2)
651 {
652     WindowAdapter windowAdapter;
653     const std::vector<uint64_t> windowIds = {1, 2};
654     std::unordered_map<uint64_t, DisplayId> windowDisplayIdMap;
655     auto err = windowAdapter.GetDisplayIdByWindowId(windowIds, windowDisplayIdMap);
656     ASSERT_EQ(err, WMError::WM_OK);
657 }
658 
659 /**
660  * @tc.name: SetGlobalDragResizeType
661  * @tc.desc: WindowAdapter/SetGlobalDragResizeType
662  * @tc.type: FUNC
663  */
664 HWTEST_F(WindowAdapterTest, SetGlobalDragResizeType, Function | SmallTest | Level2)
665 {
666     WindowAdapter windowAdapter;
667     DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
668     auto err = windowAdapter.SetGlobalDragResizeType(dragResizeType);
669     ASSERT_EQ(err, WMError::WM_OK);
670 }
671 
672 /**
673  * @tc.name: GetGlobalDragResizeType
674  * @tc.desc: WindowAdapter/GetGlobalDragResizeType
675  * @tc.type: FUNC
676  */
677 HWTEST_F(WindowAdapterTest, GetGlobalDragResizeType, Function | SmallTest | Level2)
678 {
679     WindowAdapter windowAdapter;
680     DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
681     auto err = windowAdapter.GetGlobalDragResizeType(dragResizeType);
682     ASSERT_EQ(err, WMError::WM_OK);
683 }
684 
685 /**
686  * @tc.name: SetAppDragResizeType
687  * @tc.desc: WindowAdapter/SetAppDragResizeType
688  * @tc.type: FUNC
689  */
690 HWTEST_F(WindowAdapterTest, SetAppDragResizeType, Function | SmallTest | Level2)
691 {
692     WindowAdapter windowAdapter;
693     DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
694     const std::string bundleName = "test";
695     auto err = windowAdapter.SetAppDragResizeType(bundleName, dragResizeType);
696     ASSERT_EQ(err, WMError::WM_OK);
697 }
698 
699 /**
700  * @tc.name: GetAppDragResizeType
701  * @tc.desc: WindowAdapter/GetAppDragResizeType
702  * @tc.type: FUNC
703  */
704 HWTEST_F(WindowAdapterTest, GetAppDragResizeType, Function | SmallTest | Level2)
705 {
706     WindowAdapter windowAdapter;
707     DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
708     const std::string bundleName = "test";
709     auto err = windowAdapter.GetAppDragResizeType(bundleName, dragResizeType);
710     ASSERT_EQ(err, WMError::WM_OK);
711 }
712 }
713 }
714 }