1 /*
2  * Copyright (c) 2021-2022 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 "iremote_object_mocker.h"
18 #include "window_manager.h"
19 #include "mock_window_adapter.h"
20 #include "singleton_mocker.h"
21 #include "scene_board_judgement.h"
22 #include "scene_session_manager.h"
23 
24 #include "window_manager.cpp"
25 
26 using namespace testing;
27 using namespace testing::ext;
28 
29 namespace OHOS {
30 namespace Rosen {
31 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
32 class TestCameraFloatWindowChangedListener : public ICameraFloatWindowChangedListener {
33 public:
OnCameraFloatWindowChange(uint32_t accessTokenId,bool isShowing)34     void OnCameraFloatWindowChange(uint32_t accessTokenId, bool isShowing) override
35     {
36         WLOGI("TestCameraFloatWindowChangedListener [%{public}u, %{public}u]", accessTokenId, isShowing);
37     };
38 };
39 
40 class TestVisibilityChangedListener : public IVisibilityChangedListener {
41 public:
OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>> & windowVisibilityInfo)42     void OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfo) override
43     {
44         WLOGI("TestVisibilityChangedListener");
45     };
46 };
47 
48 class TestSystemBarChangedListener : public ISystemBarChangedListener {
49 public:
OnSystemBarPropertyChange(DisplayId displayId,const SystemBarRegionTints & tints)50     void OnSystemBarPropertyChange(DisplayId displayId, const SystemBarRegionTints& tints) override
51     {
52         WLOGI("TestSystemBarChangedListener");
53     };
54 };
55 
56 class TestWindowUpdateListener : public IWindowUpdateListener {
57 public:
OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>> & infos,WindowUpdateType type)58     void OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>>& infos, WindowUpdateType type) override
59     {
60         WLOGI("TestWindowUpdateListener");
61     };
62 };
63 
64 class TestWindowModeChangedListener : public IWindowModeChangedListener {
65 public:
OnWindowModeUpdate(WindowModeType mode)66     void OnWindowModeUpdate(WindowModeType mode) override
67     {
68         WLOGI("TestWindowModeChangedListener");
69     };
70 };
71 
72 class TestWaterMarkFlagChangeListener : public IWaterMarkFlagChangedListener {
73 public:
OnWaterMarkFlagUpdate(bool showWaterMark)74     void OnWaterMarkFlagUpdate(bool showWaterMark) override
75     {
76         WLOGI("TestWaterMarkFlagChangeListener");
77     };
78 };
79 
80 class TestGestureNavigationEnabledChangedListener : public IGestureNavigationEnabledChangedListener {
81 public:
OnGestureNavigationEnabledUpdate(bool enable)82     void OnGestureNavigationEnabledUpdate(bool enable) override
83     {
84         WLOGI("TestGestureNavigationEnabledChangedListener");
85     };
86 };
87 
88 class TestDisplayInfoChangedListener : public IDisplayInfoChangedListener {
89 public:
OnDisplayInfoChange(const sptr<IRemoteObject> & token,DisplayId displayId,float density,DisplayOrientation orientation)90     void OnDisplayInfoChange(const sptr<IRemoteObject>& token, DisplayId displayId, float density,
91         DisplayOrientation orientation) override
92     {
93         TLOGI(WmsLogTag::DMS, "TestDisplayInfoChangedListener");
94     }
95 };
96 
97 class TestVisibleWindowNumChangedListener : public IVisibleWindowNumChangedListener {
98 public:
OnVisibleWindowNumChange(const std::vector<VisibleWindowNumInfo> & visibleWindowNumInfo)99     void OnVisibleWindowNumChange(const std::vector<VisibleWindowNumInfo>& visibleWindowNumInfo) override
100     {
101         for (const auto& num : visibleWindowNumInfo) {
102             GTEST_LOG_(INFO) << "displayId " << num.displayId << ", visibleWindowNum " << num.visibleWindowNum;
103         }
104     };
105 };
106 
107 class TestDrawingContentChangedListener : public IDrawingContentChangedListener {
108 public:
OnWindowDrawingContentChanged(const std::vector<sptr<WindowDrawingContentInfo>> & windowDrawingInfo)109     void OnWindowDrawingContentChanged(const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingInfo)
110     {
111         TLOGI(WmsLogTag::DMS, "TestDrawingContentChangedListener");
112     }
113 };
114 
115 class TestFocusChangedListener : public IFocusChangedListener {
116 public:
OnFocused(const sptr<FocusChangeInfo> & focusChangeInfo)117     void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo)
118     {
119         TLOGI(WmsLogTag::DMS, "TestFocusChangedListener OnFocused()");
120     }
OnUnfocused(const sptr<FocusChangeInfo> & focusChangeInfo)121     void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo)
122     {
123         TLOGI(WmsLogTag::DMS, "TestFocusChangedListener OnUnfocused()");
124     }
125 };
126 
127 class TestWindowStyleChangedListener : public IWindowStyleChangedListener {
128 public:
OnWindowStyleUpdate(WindowStyleType styleType)129     void OnWindowStyleUpdate(WindowStyleType styleType)
130     {
131         TLOGI(WmsLogTag::DMS, "TestWindowStyleChangedListener");
132     }
133 };
134 
135 class WindowManagerTest : public testing::Test {
136 public:
137     static void SetUpTestCase();
138     static void TearDownTestCase();
139     void SetUp() override;
140     void TearDown() override;
141 };
142 
SetUpTestCase()143 void WindowManagerTest::SetUpTestCase()
144 {
145 }
146 
TearDownTestCase()147 void WindowManagerTest::TearDownTestCase()
148 {
149 }
150 
SetUp()151 void WindowManagerTest::SetUp()
152 {
153 }
154 
TearDown()155 void WindowManagerTest::TearDown()
156 {
157 }
158 
159 namespace {
160 /**
161  * @tc.name: Create01
162  * @tc.desc: Create window with no WindowName and no abilityToken
163  * @tc.type: FUNC
164  */
165 HWTEST_F(WindowManagerTest, GetVisibilityWindowInfo01, Function | SmallTest | Level2)
166 {
167     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
168     std::vector<sptr<WindowVisibilityInfo>> infos;
169     infos.clear();
170     EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
171     ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetVisibilityWindowInfo(infos));
172     EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
173     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetVisibilityWindowInfo(infos));
174 }
175 
176 /**
177  * @tc.name: ToggleShownStateForAllAppWindows
178  * @tc.desc: ToggleShownStateForAllAppWindows ok
179  * @tc.type: FUNC
180  */
181 HWTEST_F(WindowManagerTest, ToggleShownStateForAllAppWindows, Function | SmallTest | Level2)
182 {
183     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
184     EXPECT_CALL(m->Mock(), ToggleShownStateForAllAppWindows()).Times(1).WillOnce(Return(WMError::WM_OK));
185     ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().ToggleShownStateForAllAppWindows());
186 }
187 
188 /**
189  * @tc.name: Create01
190  * @tc.desc: Create window with no WindowName and no abilityToken
191  * @tc.type: FUNC
192  */
193 HWTEST_F(WindowManagerTest, GetAccessibilityWindowInfo01, Function | SmallTest | Level2)
194 {
195     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
196     std::vector<sptr<AccessibilityWindowInfo>> infos;
197     infos.clear();
198     EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
199     ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
200     EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
201     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
202 }
203 
204 /**
205  * @tc.name: GetUnreliableWindowInfo
206  * @tc.desc: GetUnreliableWindowInfo ok
207  * @tc.type: FUNC
208  */
209 HWTEST_F(WindowManagerTest, GetUnreliableWindowInfo, Function | SmallTest | Level2)
210 {
211     std::unique_ptr<Mocker> mocker = std::make_unique<Mocker>();
212     int32_t windowId = 0;
213     std::vector<sptr<UnreliableWindowInfo>> infos;
214     EXPECT_CALL(mocker->Mock(), GetUnreliableWindowInfo(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
215     ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetUnreliableWindowInfo(windowId, infos));
216 }
217 
218 /**
219  * @tc.name: GetSnapshotByWindowId01
220  * @tc.desc: Check GetSnapshotByWindowId
221  * @tc.type: FUNC
222  */
223 HWTEST_F(WindowManagerTest, GetSnapshotByWindowId01, Function | SmallTest | Level2)
224 {
225     auto& windowManager = WindowManager::GetInstance();
226     int32_t windowId = -1;
227     std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
228     WMError ret = windowManager.GetSnapshotByWindowId(windowId, pixelMap);
229     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
230         ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
231     } else {
232         ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
233     }
234 }
235 
236 /**
237  * @tc.name: RegisterCameraFloatWindowChangedListener01
238  * @tc.desc: check RegisterCameraFloatWindowChangedListener
239  * @tc.type: FUNC
240  */
241 HWTEST_F(WindowManagerTest, RegisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2)
242 {
243     auto& windowManager = WindowManager::GetInstance();
244     auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
245     auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
246     windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = nullptr;
247     windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
248     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(nullptr));
249 
250     sptr<TestCameraFloatWindowChangedListener> listener = new TestCameraFloatWindowChangedListener();
251     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
252     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
253     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(listener));
254 
255     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
256     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
257     ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
258 
259     // to check that the same listner can not be registered twice
260     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
261     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
262     ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
263 
264     windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
265     windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
266 }
267 
268 /**
269  * @tc.name: UnregisterCameraFloatWindowChangedListener01
270  * @tc.desc: check UnregisterCameraFloatWindowChangedListener
271  * @tc.type: FUNC
272  */
273 HWTEST_F(WindowManagerTest, UnregisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2)
274 {
275     auto& windowManager = WindowManager::GetInstance();
276     auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
277     auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
278     windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = new WindowManagerAgent();
279     windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
280 
281     // check nullpter
282     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraFloatWindowChangedListener(nullptr));
283 
284     sptr<TestCameraFloatWindowChangedListener> listener1 = new TestCameraFloatWindowChangedListener();
285     sptr<TestCameraFloatWindowChangedListener> listener2 = new TestCameraFloatWindowChangedListener();
286     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
287 
288     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
289     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
290     windowManager.RegisterCameraFloatWindowChangedListener(listener1);
291     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
292     windowManager.RegisterCameraFloatWindowChangedListener(listener2);
293     ASSERT_EQ(2, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
294 
295     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
296 
297 
298     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
299     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener2));
300     ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
301     ASSERT_EQ(nullptr, windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_);
302 
303     windowManager.pImpl_->cameraFloatWindowChangedListeners_.emplace_back(listener1);
304     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
305     ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
306 
307     windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
308     windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
309 }
310 
311 /**
312  * @tc.name: RegisterVisibilityChangedListener01
313  * @tc.desc: check RegisterVisibilityChangedListener
314  * @tc.type: FUNC
315  */
316 HWTEST_F(WindowManagerTest, RegisterVisibilityChangedListener01, Function | SmallTest | Level2)
317 {
318     auto& windowManager = WindowManager::GetInstance();
319     auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
320     auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
321     windowManager.pImpl_->windowVisibilityListenerAgent_ = nullptr;
322     windowManager.pImpl_->windowVisibilityListeners_.clear();
323     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(nullptr));
324 
325     sptr<TestVisibilityChangedListener> listener = new TestVisibilityChangedListener();
326     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
327     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
328     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(listener));
329     ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
330 
331     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
332     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
333     ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
334 
335     // to check that the same listner can not be registered twice
336     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
337     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
338     ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
339 
340     windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
341     windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
342 }
343 
344 /**
345  * @tc.name: UnregisterVisibilityChangedListener01
346  * @tc.desc: check UnregisterVisibilityChangedListener
347  * @tc.type: FUNC
348  */
349 HWTEST_F(WindowManagerTest, UnregisterVisibilityChangedListener01, Function | SmallTest | Level2)
350 {
351     auto& windowManager = WindowManager::GetInstance();
352     auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
353     auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
354     windowManager.pImpl_->windowVisibilityListenerAgent_ = new WindowManagerAgent();
355     windowManager.pImpl_->windowVisibilityListeners_.clear();
356 
357     // check nullpter
358     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityChangedListener(nullptr));
359 
360     sptr<TestVisibilityChangedListener> listener1 = new TestVisibilityChangedListener();
361     sptr<TestVisibilityChangedListener> listener2 = new TestVisibilityChangedListener();
362 
363     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
364     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
365     windowManager.RegisterVisibilityChangedListener(listener1);
366     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
367     windowManager.RegisterVisibilityChangedListener(listener2);
368     ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityListeners_.size());
369 
370     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
371     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
372     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener2));
373     ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
374     ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
375 
376     windowManager.pImpl_->windowVisibilityListeners_.emplace_back(listener1);
377     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
378     ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
379 
380     windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
381     windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
382 }
383 
384 /**
385  * @tc.name: RegisterWindowUpdateListener01
386  * @tc.desc: check RegisterWindowUpdateListener
387  * @tc.type: FUNC
388  */
389 HWTEST_F(WindowManagerTest, RegisterWindowUpdateListener01, Function | SmallTest | Level2)
390 {
391     auto& windowManager = WindowManager::GetInstance();
392     auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
393     auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
394     windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
395     windowManager.pImpl_->windowUpdateListeners_.clear();
396     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr));
397 
398     sptr<TestWindowUpdateListener> listener = new TestWindowUpdateListener();
399     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
400     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
401     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener));
402     ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
403 
404     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
405     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
406     ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
407 
408     // to check that the same listner can not be registered twice
409     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
410     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
411     ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
412 
413     windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
414     windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
415 }
416 
417 /**
418  * @tc.name: UnregisterWindowUpdateListener01
419  * @tc.desc: check UnregisterWindowUpdateListener
420  * @tc.type: FUNC
421  */
422 HWTEST_F(WindowManagerTest, UnregisterWindowUpdateListener01, Function | SmallTest | Level2)
423 {
424     auto& windowManager = WindowManager::GetInstance();
425     auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
426     auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
427     windowManager.pImpl_->windowUpdateListenerAgent_ = new WindowManagerAgent();
428     windowManager.pImpl_->windowUpdateListeners_.clear();
429 
430     // check nullpter
431     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr));
432 
433     sptr<TestWindowUpdateListener> listener1 = new TestWindowUpdateListener();
434     sptr<TestWindowUpdateListener> listener2 = new TestWindowUpdateListener();
435     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
436 
437     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
438     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
439     windowManager.RegisterWindowUpdateListener(listener1);
440     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
441     windowManager.RegisterWindowUpdateListener(listener2);
442     ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
443 
444     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
445     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
446     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2));
447     ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
448     ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
449 
450     windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
451     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
452     ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
453 
454     windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
455     windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
456 }
457 
458 /**
459  * @tc.name: RegisterWindowModeChangedListener01
460  * @tc.desc: check RegisterWindowModeChangedListener
461  * @tc.type: FUNC
462  */
463 HWTEST_F(WindowManagerTest, RegisterWindowModeChangedListener01, Function | SmallTest | Level2)
464 {
465     auto &windowManager = WindowManager::GetInstance();
466     auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
467     auto oldListeners = windowManager.pImpl_->windowModeListeners_;
468     windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
469     windowManager.pImpl_->windowModeListeners_.clear();
470     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(nullptr));
471 
472     sptr<TestWindowModeChangedListener> listener = new TestWindowModeChangedListener();
473     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
474     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
475     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(listener));
476     ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
477 
478     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
479     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
480     ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
481 
482     // to check that the same listner can not be registered twice
483     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
484     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
485     ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
486 
487     windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
488     windowManager.pImpl_->windowModeListeners_ = oldListeners;
489 }
490 
491 /**
492  * @tc.name: UnregisterWindowModeChangedListener01
493  * @tc.desc: check UnregisterWindowModeChangedListener
494  * @tc.type: FUNC
495  */
496 HWTEST_F(WindowManagerTest, UnregisterWindowModeChangedListener01, Function | SmallTest | Level2)
497 {
498     auto &windowManager = WindowManager::GetInstance();
499     auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
500     auto oldListeners = windowManager.pImpl_->windowModeListeners_;
501     windowManager.pImpl_->windowModeListenerAgent_ = new WindowManagerAgent();
502     windowManager.pImpl_->windowModeListeners_.clear();
503 
504     // check nullpter
505     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowModeChangedListener(nullptr));
506 
507     sptr<TestWindowModeChangedListener> listener1 = new TestWindowModeChangedListener();
508     sptr<TestWindowModeChangedListener> listener2 = new TestWindowModeChangedListener();
509     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
510 
511     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
512     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
513     windowManager.RegisterWindowModeChangedListener(listener1);
514     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
515     windowManager.RegisterWindowModeChangedListener(listener2);
516     ASSERT_EQ(2, windowManager.pImpl_->windowModeListeners_.size());
517 
518     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
519     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
520     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener2));
521     ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
522     ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
523 
524     windowManager.pImpl_->windowModeListeners_.emplace_back(listener1);
525     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
526     ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
527 
528     windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
529     windowManager.pImpl_->windowModeListeners_ = oldListeners;
530 }
531 
532 /**
533  * @tc.name: RegisterSystemBarChangedListener01
534  * @tc.desc: check RegisterSystemBarChangedListener
535  * @tc.type: FUNC
536  */
537 HWTEST_F(WindowManagerTest, RegisterSystemBarChangedListener01, Function | SmallTest | Level2)
538 {
539     auto& windowManager = WindowManager::GetInstance();
540     auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
541     auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
542     windowManager.pImpl_->systemBarChangedListenerAgent_ = nullptr;
543     windowManager.pImpl_->systemBarChangedListeners_.clear();
544     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(nullptr));
545 
546     sptr<ISystemBarChangedListener> listener = new TestSystemBarChangedListener();
547     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
548     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
549     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(listener));
550     ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
551 
552     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
553     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
554     ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
555 
556     // to check that the same listner can not be registered twice
557     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
558     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
559     ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
560 
561     windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
562     windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
563 }
564 
565 /**
566  * @tc.name: UnregisterSystemBarChangedListener01
567  * @tc.desc: check UnregisterSystemBarChangedListener
568  * @tc.type: FUNC
569  */
570 HWTEST_F(WindowManagerTest, UnregisterSystemBarChangedListener01, Function | SmallTest | Level2)
571 {
572     auto& windowManager = WindowManager::GetInstance();
573     auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
574     auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
575     windowManager.pImpl_->systemBarChangedListenerAgent_ = new WindowManagerAgent();
576     windowManager.pImpl_->systemBarChangedListeners_.clear();
577     // check nullpter
578     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterSystemBarChangedListener(nullptr));
579 
580     sptr<TestSystemBarChangedListener> listener1 = new TestSystemBarChangedListener();
581     sptr<TestSystemBarChangedListener> listener2 = new TestSystemBarChangedListener();
582     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
583 
584     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
585     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
586     windowManager.RegisterSystemBarChangedListener(listener1);
587     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
588     windowManager.RegisterSystemBarChangedListener(listener2);
589     ASSERT_EQ(2, windowManager.pImpl_->systemBarChangedListeners_.size());
590 
591 
592     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
593     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
594     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener2));
595     ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
596     ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
597 
598     windowManager.pImpl_->systemBarChangedListeners_.push_back(listener1);
599     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
600     ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
601 
602     windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
603     windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
604 }
605 
606 /**
607  * @tc.name: RegisterWaterMarkListener01
608  * @tc.desc: check RegisterWaterMarkListener
609  * @tc.type: FUNC
610  */
611 HWTEST_F(WindowManagerTest, RegisterWaterMarkFlagChangedListener01, Function | SmallTest | Level2)
612 {
613     auto& windowManager = WindowManager::GetInstance();
614 
615     windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
616     windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
617 
618     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(nullptr));
619 
620     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
621     sptr<TestWaterMarkFlagChangeListener> listener = new TestWaterMarkFlagChangeListener();
622     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
623 
624     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(listener));
625     ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
626     ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
627 
628     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
629     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
630     ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
631     ASSERT_NE(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
632 
633     // to check that the same listner can not be registered twice
634     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
635     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
636     ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
637 }
638 
639 /**
640  * @tc.name: UnregisterWaterMarkFlagChangedListener01
641  * @tc.desc: check UnregisterWaterMarkFlagChangedListener
642  * @tc.type: FUNC
643  */
644 HWTEST_F(WindowManagerTest, UnregisterWaterMarkFlagChangedListener01, Function | SmallTest | Level2)
645 {
646     auto& windowManager = WindowManager::GetInstance();
647     windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
648     windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
649     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
650 
651     // check nullpter
652     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWaterMarkFlagChangedListener(nullptr));
653 
654     sptr<TestWaterMarkFlagChangeListener> listener1 = new TestWaterMarkFlagChangeListener();
655     sptr<TestWaterMarkFlagChangeListener> listener2 = new TestWaterMarkFlagChangeListener();
656     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
657 
658     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
659     windowManager.RegisterWaterMarkFlagChangedListener(listener1);
660     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
661     windowManager.RegisterWaterMarkFlagChangedListener(listener2);
662     ASSERT_EQ(2, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
663 
664     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
665     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
666     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener2));
667     ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
668     ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
669 
670     // if agent == nullptr, it can not be crashed.
671     windowManager.pImpl_->waterMarkFlagChangeListeners_.push_back(listener1);
672     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
673     ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
674 }
675 
676 /**
677  * @tc.name: RegisterGestureNavigationEnabledChangedListener
678  * @tc.desc: check RegisterGestureNavigationEnabledChangedListener
679  * @tc.type: FUNC
680  */
681 HWTEST_F(WindowManagerTest, RegisterGestureNavigationEnabledChangedListener, Function | SmallTest | Level2)
682 {
683     auto& windowManager = WindowManager::GetInstance();
684 
685     windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
686     windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
687 
688     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(nullptr));
689 
690     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
691     sptr<TestGestureNavigationEnabledChangedListener> listener = new TestGestureNavigationEnabledChangedListener();
692     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
693 
694     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
695     ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
696     ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
697 
698     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
699     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
700     ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
701     ASSERT_NE(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
702 
703     // to check that the same listner can not be registered twice
704     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
705     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
706     ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
707 }
708 
709 /**
710  * @tc.name: UnregisterGestureNavigationEnabledChangedListener
711  * @tc.desc: check UnregisterGestureNavigationEnabledChangedListener
712  * @tc.type: FUNC
713  */
714 HWTEST_F(WindowManagerTest, UnregisterGestureNavigationEnabledChangedListener, Function | SmallTest | Level2)
715 {
716     auto& windowManager = WindowManager::GetInstance();
717     windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
718     windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
719     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
720 
721     // check nullpter
722     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterGestureNavigationEnabledChangedListener(nullptr));
723 
724     sptr<TestGestureNavigationEnabledChangedListener> listener1 = new TestGestureNavigationEnabledChangedListener();
725     sptr<TestGestureNavigationEnabledChangedListener> listener2 = new TestGestureNavigationEnabledChangedListener();
726     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM,
727         windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
728 
729     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
730     windowManager.RegisterGestureNavigationEnabledChangedListener(listener1);
731     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
732     windowManager.RegisterGestureNavigationEnabledChangedListener(listener2);
733     ASSERT_EQ(2, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
734 
735     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
736     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
737     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener2));
738     ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
739     ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
740 
741     // if agent == nullptr, it can not be crashed.
742     windowManager.pImpl_->gestureNavigationEnabledListeners_.push_back(listener1);
743     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
744     ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
745 }
746 
747 /**
748  * @tc.name: GetUIContentRemoteObj
749  * @tc.desc: GetUIContentRemoteObj
750  * @tc.type: FUNC
751  */
752 HWTEST_F(WindowManagerTest, GetUIContentRemoteObj, Function | SmallTest | Level2)
753 {
754     sptr<IRemoteObject> remoteObj;
755     WMError res = WindowManager::GetInstance().GetUIContentRemoteObj(1, remoteObj);
756     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
757         ASSERT_EQ(res, WMError::WM_ERROR_IPC_FAILED);
758         return;
759     }
760     ASSERT_EQ(res, WMError::WM_OK);
761 }
762 
763 /**
764  * @tc.name: GetFocusWindowInfo
765  * @tc.desc: window GetFocusWindowInfo
766  * @tc.type: FUNC
767  */
768 HWTEST_F(WindowManagerTest, GetFocusWindowInfo, Function | SmallTest | Level2)
769 {
770     FocusChangeInfo focusInfo;
771     auto ret = 0;
772     WindowManager::GetInstance().GetFocusWindowInfo(focusInfo);
773     ASSERT_EQ(0, ret);
774 }
775 
776 /**
777  * @tc.name: MinimizeAllAppWindows
778  * @tc.desc: window MinimizeAllAppWindows
779  * @tc.type: FUNC
780  */
781 HWTEST_F(WindowManagerTest, MinimizeAllAppWindows, Function | SmallTest | Level2)
782 {
783     DisplayId displayId = 0;
784     WMError ret = WindowManager::GetInstance().MinimizeAllAppWindows(displayId);
785     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
786         ASSERT_NE(ret, WMError::WM_OK);
787     } else {
788         ASSERT_EQ(ret, WMError::WM_OK);
789     }
790 }
791 
792 /**
793  * @tc.name: SetWindowLayoutMode
794  * @tc.desc: window SetWindowLayoutMode
795  * @tc.type: FUNC
796  */
797 HWTEST_F(WindowManagerTest, SetWindowLayoutMode, Function | SmallTest | Level2)
798 {
799     WMError ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::BASE);
800     ASSERT_EQ(ret, WMError::WM_OK);
801 
802     ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
803     ASSERT_EQ(ret, WMError::WM_OK);
804 
805     ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::END);
806     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
807         ASSERT_EQ(ret, WMError::WM_OK);
808     } else {
809         ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_PARAM);
810     }
811 }
812 
813 /**
814  * @tc.name: UpdateCameraFloatWindowStatus
815  * @tc.desc: UpdateCameraFloatWindowStatus
816  * @tc.type: FUNC
817  */
818 HWTEST_F(WindowManagerTest, UpdateCameraFloatWindowStatus, Function | SmallTest | Level2)
819 {
820     uint32_t accessTokenId = 0;
821     bool isShowing = true;
822     auto ret = 0;
823     WindowManager::GetInstance().UpdateCameraFloatWindowStatus(accessTokenId, isShowing);
824     ASSERT_EQ(0, ret);
825 }
826 
827 /**
828  * @tc.name: NotifyWaterMarkFlagChangedResult
829  * @tc.desc: NotifyWaterMarkFlagChangedResult
830  * @tc.type: FUNC
831  */
832 HWTEST_F(WindowManagerTest, NotifyWaterMarkFlagChangedResult, Function | SmallTest | Level2)
833 {
834     bool showwatermark = true;
835     auto ret = 0;
836     WindowManager::GetInstance().NotifyWaterMarkFlagChangedResult(showwatermark);
837     ASSERT_EQ(0, ret);
838 }
839 
840 /**
841  * @tc.name: NotifyGestureNavigationEnabledResult
842  * @tc.desc: NotifyGestureNavigationEnabledResult
843  * @tc.type: FUNC
844  */
845 HWTEST_F(WindowManagerTest, NotifyGestureNavigationEnabledResult, Function | SmallTest | Level2)
846 {
847     bool enable = true;
848     auto ret = 0;
849     WindowManager::GetInstance().NotifyGestureNavigationEnabledResult(enable);
850     ASSERT_EQ(0, ret);
851 }
852 
853 /**
854  * @tc.name: DumpSessionAll
855  * @tc.desc: DumpSessionAll
856  * @tc.type: FUNC
857  */
858 HWTEST_F(WindowManagerTest, DumpSessionAll, Function | SmallTest | Level2)
859 {
860     std::vector<std::string> infos;
861     infos.push_back("DumpSessionWithId");
862     WMError res = WindowManager::GetInstance().DumpSessionAll(infos);
863     ASSERT_EQ(WMError::WM_OK, res);
864 }
865 
866 /**
867  * @tc.name: DumpSessionWithId
868  * @tc.desc: DumpSessionWithId
869  * @tc.type: FUNC
870  */
871 HWTEST_F(WindowManagerTest, DumpSessionWithId, Function | SmallTest | Level2)
872 {
873     std::vector<std::string> infos;
874     infos.push_back("DumpSessionWithId");
875     int32_t persistentId = 0;
876     WMError res = WindowManager::GetInstance().DumpSessionWithId(persistentId, infos);
877     ASSERT_EQ(WMError::WM_OK, res);
878 }
879 
880 /**
881  * @tc.name: GetWindowModeType01
882  * @tc.desc: GetWindowModeType01
883  * @tc.type: FUNC
884  */
885 HWTEST_F(WindowManagerTest, GetWindowModeType01, Function | SmallTest | Level2)
886 {
887     std::vector<sptr<AccessibilityWindowInfo>> infos;
888     infos.clear();
889     WindowModeType windowModeType;
890     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
891     EXPECT_CALL(m->Mock(), GetWindowModeType(_)).Times(1).WillOnce(Return(WMError::WM_OK));
892     ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetWindowModeType(windowModeType));
893 }
894 
895 /**
896  * @tc.name: RegisterVisibleWindowNumChangedListener
897  * @tc.desc: check RegisterVisibleWindowNumChangedListener
898  * @tc.type: FUNC
899  */
900 HWTEST_F(WindowManagerTest, RegisterVisibleWindowNumChangedListener, Function | SmallTest | Level2)
901 {
902     auto& windowManager = WindowManager::GetInstance();
903 
904     windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
905     windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
906 
907     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibleWindowNumChangedListener(nullptr));
908 
909     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
910     sptr<TestVisibleWindowNumChangedListener> listener = new TestVisibleWindowNumChangedListener();
911     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
912 
913     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibleWindowNumChangedListener(listener));
914     ASSERT_EQ(0, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
915     ASSERT_EQ(nullptr, windowManager.pImpl_->visibleWindowNumChangedListenerAgent_);
916 
917     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
918     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
919     ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
920     ASSERT_NE(nullptr, windowManager.pImpl_->visibleWindowNumChangedListenerAgent_);
921 
922     // to check that the same listner can not be registered twice
923     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
924     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
925     ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
926 }
927 
928 /**
929  * @tc.name: UnregisterVisibleWindowNumChangedListener
930  * @tc.desc: check UnregisterVisibleWindowNumChangedListener
931  * @tc.type: FUNC
932  */
933 HWTEST_F(WindowManagerTest, UnregisterVisibleWindowNumChangedListener, Function | SmallTest | Level2)
934 {
935     auto& windowManager = WindowManager::GetInstance();
936     windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
937     windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
938     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
939 
940     // check nullpter
941     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibleWindowNumChangedListener(nullptr));
942 
943     sptr<TestVisibleWindowNumChangedListener> listener1 = new TestVisibleWindowNumChangedListener();
944     sptr<TestVisibleWindowNumChangedListener> listener2 = new TestVisibleWindowNumChangedListener();
945 
946     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
947     windowManager.RegisterVisibleWindowNumChangedListener(listener1);
948     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
949     windowManager.RegisterVisibleWindowNumChangedListener(listener2);
950     ASSERT_EQ(2, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
951 
952     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener1));
953     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener2));
954     ASSERT_EQ(2, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
955 
956     // if agent == nullptr, it can not be crashed.
957     windowManager.pImpl_->visibleWindowNumChangedListeners_.push_back(listener1);
958     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener1));
959     ASSERT_EQ(3, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
960 }
961 
962 /**
963  * @tc.name: RegisterAndOnVisibleWindowNumChanged
964  * @tc.desc: check RegisterAndOnVisibleWindowNumChanged
965  * @tc.type: FUNC
966  */
967 HWTEST_F(WindowManagerTest, RegisterAndOnVisibleWindowNumChanged, Function | SmallTest | Level2)
968 {
969     auto& windowManager = WindowManager::GetInstance();
970     windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
971     windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
972 
973     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
974     sptr<TestVisibleWindowNumChangedListener> listener = new TestVisibleWindowNumChangedListener();
975     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
976     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
977     ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
978 
979     std::vector<VisibleWindowNumInfo> visibleWindowNumInfo;
980     VisibleWindowNumInfo newInfo;
981     newInfo.displayId = 0;
982     newInfo.visibleWindowNum = 2;
983     visibleWindowNumInfo.push_back(newInfo);
984     auto ret = 0;
985     windowManager.UpdateVisibleWindowNum(visibleWindowNumInfo);
986     ASSERT_EQ(0, ret);
987 }
988 
989 /**
990  * @tc.name: Test01
991  * @tc.desc: Test01
992  * @tc.type: FUNC
993  */
994 HWTEST_F(WindowManagerTest, Test01, Function | SmallTest | Level2)
995 {
996     sptr<IWMSConnectionChangedListener> listener = nullptr;
997     WMError res = WindowManager::GetInstance().RegisterWMSConnectionChangedListener(listener);
998     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, res);
999     WMError res1 = WindowManager::GetInstance().UnregisterWMSConnectionChangedListener();
1000     ASSERT_EQ(WMError::WM_OK, res1);
1001     WindowManager::GetInstance().RaiseWindowToTop(5);
1002     WMError res3 = WindowManager::GetInstance().NotifyWindowExtensionVisibilityChange(5, 5, true);
1003     ASSERT_EQ(WMError::WM_OK, res3);
1004     WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1005 }
1006 
1007 /**
1008  * @tc.name: RegisterDisplayInfoChangedListener
1009  * @tc.desc: check RegisterDisplayInfoChangedListener
1010  * @tc.type: FUNC
1011  */
1012 HWTEST_F(WindowManagerTest, RegisterDisplayInfoChangedListener, Function | SmallTest | Level2)
1013 {
1014     auto& windowManager = WindowManager::GetInstance();
1015     windowManager.pImpl_->displayInfoChangedListeners_.clear();
1016 
1017     sptr<IRemoteObject> targetToken = nullptr;
1018     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(targetToken, nullptr));
1019 
1020     targetToken = new (std::nothrow) IRemoteObjectMocker();
1021     ASSERT_NE(nullptr, targetToken);
1022     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(targetToken, nullptr));
1023 
1024     sptr<IDisplayInfoChangedListener> listener = new (std::nothrow) TestDisplayInfoChangedListener();
1025     ASSERT_NE(nullptr, listener);
1026     sptr<IDisplayInfoChangedListener> listener2 = new (std::nothrow) TestDisplayInfoChangedListener();
1027     ASSERT_NE(nullptr, listener2);
1028 
1029     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(nullptr, listener));
1030     ASSERT_EQ(0, windowManager.pImpl_->displayInfoChangedListeners_.size());
1031     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
1032     ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1033 
1034     // to check that the same listner can not be registered twice
1035     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
1036     ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1037 
1038     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener2));
1039     ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1040     auto iter = windowManager.pImpl_->displayInfoChangedListeners_.find(targetToken);
1041     ASSERT_NE(windowManager.pImpl_->displayInfoChangedListeners_.end(), iter);
1042     ASSERT_EQ(2, iter->second.size());
1043 }
1044 
1045 /**
1046  * @tc.name: UnregisterDisplayInfoChangedListener
1047  * @tc.desc: check UnregisterDisplayInfoChangedListener
1048  * @tc.type: FUNC
1049  */
1050 HWTEST_F(WindowManagerTest, UnregisterDisplayInfoChangedListener, Function | SmallTest | Level2)
1051 {
1052     auto& windowManager = WindowManager::GetInstance();
1053     windowManager.pImpl_->displayInfoChangedListeners_.clear();
1054 
1055     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(nullptr, nullptr));
1056 
1057     sptr<IRemoteObject> targetToken = new (std::nothrow) IRemoteObjectMocker();
1058     ASSERT_NE(nullptr, targetToken);
1059     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(targetToken, nullptr));
1060 
1061     sptr<IDisplayInfoChangedListener> listener = new (std::nothrow) TestDisplayInfoChangedListener();
1062     ASSERT_NE(nullptr, listener);
1063     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(nullptr, listener));
1064 
1065     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener));
1066 
1067     sptr<IRemoteObject> targetToken2 = new (std::nothrow) IRemoteObjectMocker();
1068     ASSERT_NE(nullptr, targetToken2);
1069     sptr<IDisplayInfoChangedListener> listener2 = new (std::nothrow) TestDisplayInfoChangedListener();
1070     ASSERT_NE(nullptr, listener2);
1071 
1072     // the same token can have multiple listeners
1073     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
1074     ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1075     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener2));
1076     ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1077     auto iter = windowManager.pImpl_->displayInfoChangedListeners_.find(targetToken);
1078     ASSERT_NE(windowManager.pImpl_->displayInfoChangedListeners_.end(), iter);
1079     ASSERT_EQ(2, iter->second.size());
1080 
1081     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken2, listener));
1082     ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size());
1083 
1084     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener));
1085     ASSERT_EQ(1, iter->second.size());
1086     ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size());
1087 
1088     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener2));
1089     ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1090     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken2, listener));
1091     ASSERT_EQ(0, windowManager.pImpl_->displayInfoChangedListeners_.size());
1092 }
1093 
1094 /**
1095  * @tc.name: NotifyDisplayInfoChanged
1096  * @tc.desc: check NotifyDisplayInfoChanged
1097  * @tc.type: FUNC
1098  */
1099 HWTEST_F(WindowManagerTest, NotifyDisplayInfoChanged, Function | SmallTest | Level2)
1100 {
1101     sptr<IRemoteObject> targetToken = new (std::nothrow) IRemoteObjectMocker();
1102     ASSERT_NE(nullptr, targetToken);
1103     DisplayId displayId = 0;
1104     float density = 0.2f;
1105     DisplayOrientation orientation = DisplayOrientation::UNKNOWN;
1106 
1107     auto& windowManager = WindowManager::GetInstance();
1108     windowManager.pImpl_->displayInfoChangedListeners_.clear();
1109     windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation);
1110 
1111     sptr<IRemoteObject> targetToken2 = new (std::nothrow) IRemoteObjectMocker();
1112     ASSERT_NE(nullptr, targetToken2);
1113     sptr<IDisplayInfoChangedListener> listener = new (std::nothrow) TestDisplayInfoChangedListener();
1114     ASSERT_NE(nullptr, listener);
1115 
1116     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
1117     ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1118     windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation);
1119 
1120     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken2, listener));
1121     ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size());
1122     windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation);
1123     windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken2, displayId, density, orientation);
1124     // no repeated notification is sent if parameters do not change
1125     windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation);
1126 }
1127 
1128 /**
1129  * @tc.name: RegisterWindowStyleChangedListener
1130  * @tc.desc: check RegisterWindowStyleChangedListener
1131  * @tc.type: FUNC
1132  */
1133 HWTEST_F(WindowManagerTest, RegisterWindowStyleChangedListener, Function | SmallTest | Level2)
1134 {
1135     auto& windowManager = WindowManager::GetInstance();
1136     auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
1137     auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
1138     windowManager.pImpl_->windowStyleListenerAgent_ = nullptr;
1139     windowManager.pImpl_->windowStyleListeners_.clear();
1140     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(nullptr));
1141 
1142     sptr<IWindowStyleChangedListener> listener = new TestWindowStyleChangedListener();
1143     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1144     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1145     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(listener));
1146     ASSERT_EQ(nullptr, windowManager.pImpl_->windowStyleListenerAgent_);
1147 
1148     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1149     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
1150     ASSERT_EQ(1, windowManager.pImpl_->windowStyleListeners_.size());
1151 
1152     // to check that the same listner can not be registered twice
1153     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
1154     ASSERT_EQ(1, windowManager.pImpl_->windowStyleListeners_.size());
1155 
1156     windowManager.pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
1157     windowManager.pImpl_->windowStyleListeners_ = oldListeners;
1158 }
1159 
1160 /**
1161  * @tc.name: UnregisterWindowStyleChangedListener
1162  * @tc.desc: check UnregisterWindowStyleChangedListener
1163  * @tc.type: FUNC
1164  */
1165 HWTEST_F(WindowManagerTest, UnregisterWindowStyleChangedListener, Function | SmallTest | Level2)
1166 {
1167     auto& windowManager = WindowManager::GetInstance();
1168     auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
1169     auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
1170     windowManager.pImpl_->windowStyleListenerAgent_ = new WindowManagerAgent();
1171     windowManager.pImpl_->windowStyleListeners_.clear();
1172     // check nullpter
1173     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowStyleChangedListener(nullptr));
1174 
1175     sptr<TestWindowStyleChangedListener> listener1 = new TestWindowStyleChangedListener();
1176     sptr<TestWindowStyleChangedListener> listener2 = new TestWindowStyleChangedListener();
1177     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
1178 }
1179 
1180 /**
1181  * @tc.name: NotifyWindowStyleChange
1182  * @tc.desc: check NotifyWindowStyleChange
1183  * @tc.type: FUNC
1184  */
1185 HWTEST_F(WindowManagerTest, NotifyWindowStyleChange, Function | SmallTest | Level2)
1186 {
1187     WindowStyleType type = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
1188     auto ret = WindowManager::GetInstance().NotifyWindowStyleChange(type);
1189     ASSERT_EQ(WMError::WM_OK, ret);
1190 }
1191 
1192 /**
1193  * @tc.name: GetWindowStyleType
1194  * @tc.desc: check GetWindowStyleType
1195  * @tc.type: FUNC
1196  */
1197 HWTEST_F(WindowManagerTest, GetWindowStyleType, Function | SmallTest | Level2)
1198 {
1199     WindowStyleType type;
1200     type = WindowManager::GetInstance().GetWindowStyleType();
1201     ASSERT_EQ(Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT, type);
1202 }
1203 
1204 /**
1205  * @tc.name: ShiftAppWindowFocus01
1206  * @tc.desc: check ShiftAppWindowFocus
1207  * @tc.type: FUNC
1208  */
1209 HWTEST_F(WindowManagerTest, ShiftAppWindowFocus01, Function | SmallTest | Level2)
1210 {
1211     WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1212     ASSERT_NE(WMError::WM_OK, ret);
1213 }
1214 
1215 /**
1216  * @tc.name: RegisterVisibleWindowNumChangedListener01
1217  * @tc.desc: check RegisterVisibleWindowNumChangedListener
1218  * @tc.type: FUNC
1219  */
1220 HWTEST_F(WindowManagerTest, RegisterVisibleWindowNumChangedListener01, Function | SmallTest | Level2)
1221 {
1222     WMError ret;
1223     sptr<IVisibleWindowNumChangedListener> listener = new (std::nothrow) TestVisibleWindowNumChangedListener();
1224     ret = WindowManager::GetInstance().RegisterVisibleWindowNumChangedListener(listener);
1225     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1226         ASSERT_NE(WMError::WM_OK, ret);
1227     } else {
1228         ASSERT_EQ(WMError::WM_OK, ret);
1229     }
1230 
1231     ret = WindowManager::GetInstance().RegisterVisibleWindowNumChangedListener(nullptr);
1232     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1233 }
1234 
1235 /**
1236  * @tc.name: UnregisterVisibleWindowNumChangedListener01
1237  * @tc.desc: check UnregisterVisibleWindowNumChangedListener
1238  * @tc.type: FUNC
1239  */
1240 HWTEST_F(WindowManagerTest, UnregisterVisibleWindowNumChangedListener01, Function | SmallTest | Level2)
1241 {
1242     WMError ret;
1243     sptr<IVisibleWindowNumChangedListener> listener = new (std::nothrow) TestVisibleWindowNumChangedListener();
1244     ret = WindowManager::GetInstance().UnregisterVisibleWindowNumChangedListener(listener);
1245     ASSERT_EQ(WMError::WM_OK, ret);
1246 
1247     ret = WindowManager::GetInstance().UnregisterVisibleWindowNumChangedListener(nullptr);
1248     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1249 }
1250 
1251 /**
1252  * @tc.name: RegisterDrawingContentChangedListener01
1253  * @tc.desc: check RegisterDrawingContentChangedListener
1254  * @tc.type: FUNC
1255  */
1256 HWTEST_F(WindowManagerTest, RegisterDrawingContentChangedListener01, Function | SmallTest | Level2)
1257 {
1258     WMError ret;
1259     sptr<IDrawingContentChangedListener> listener = new (std::nothrow) TestDrawingContentChangedListener();
1260     ret = WindowManager::GetInstance().RegisterDrawingContentChangedListener(listener);
1261     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1262         ASSERT_NE(WMError::WM_OK, ret);
1263     } else {
1264         ASSERT_EQ(WMError::WM_OK, ret);
1265     }
1266 
1267     ret = WindowManager::GetInstance().RegisterDrawingContentChangedListener(nullptr);
1268     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1269 }
1270 
1271 /**
1272  * @tc.name: UnregisterDrawingContentChangedListener01
1273  * @tc.desc: check UnregisterDrawingContentChangedListener
1274  * @tc.type: FUNC
1275  */
1276 HWTEST_F(WindowManagerTest, UnregisterDrawingContentChangedListener01, Function | SmallTest | Level2)
1277 {
1278     WMError ret;
1279     sptr<IDrawingContentChangedListener> listener = new (std::nothrow) TestDrawingContentChangedListener();
1280     ret = WindowManager::GetInstance().UnregisterDrawingContentChangedListener(listener);
1281     ASSERT_EQ(WMError::WM_OK, ret);
1282 
1283     ret = WindowManager::GetInstance().UnregisterDrawingContentChangedListener(nullptr);
1284     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1285 }
1286 
1287 /**
1288  * @tc.name: RegisterFocusChangedListener01
1289  * @tc.desc: check RegisterFocusChangedListener
1290  * @tc.type: FUNC
1291  */
1292 HWTEST_F(WindowManagerTest, RegisterFocusChangedListener01, Function | SmallTest | Level2)
1293 {
1294     WMError ret;
1295     sptr<IFocusChangedListener> listener = new (std::nothrow) TestFocusChangedListener();
1296     ret = WindowManager::GetInstance().RegisterFocusChangedListener(listener);
1297     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1298         ASSERT_NE(WMError::WM_OK, ret);
1299     } else {
1300         ASSERT_EQ(WMError::WM_OK, ret);
1301     }
1302 
1303     ret = WindowManager::GetInstance().RegisterFocusChangedListener(nullptr);
1304     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1305 }
1306 
1307 /**
1308  * @tc.name: UnregisterFocusChangedListener01
1309  * @tc.desc: check UnregisterFocusChangedListener
1310  * @tc.type: FUNC
1311  */
1312 HWTEST_F(WindowManagerTest, UnregisterFocusChangedListener01, Function | SmallTest | Level2)
1313 {
1314     WMError ret;
1315     sptr<IFocusChangedListener> listener = new (std::nothrow) TestFocusChangedListener();
1316     ret = WindowManager::GetInstance().UnregisterFocusChangedListener(listener);
1317     ASSERT_EQ(WMError::WM_OK, ret);
1318 
1319     ret = WindowManager::GetInstance().UnregisterFocusChangedListener(nullptr);
1320     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1321 }
1322 
1323 /**
1324  * @tc.name: NotifyDisplayInfoChange01
1325  * @tc.desc: check NotifyDisplayInfoChange
1326  * @tc.type: FUNC
1327  */
1328 HWTEST_F(WindowManagerTest, NotifyDisplayInfoChange01, Function | SmallTest | Level2)
1329 {
1330     WMError ret;
1331     ret = WindowManager::GetInstance().NotifyDisplayInfoChange(nullptr, 1, 2, DisplayOrientation::PORTRAIT);
1332     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1333 }
1334 
1335 /**
1336  * @tc.name: NotifyDisplayInfoChange02
1337  * @tc.desc: check NotifyDisplayInfoChange, token is not nullptr
1338  * @tc.type: FUNC
1339  */
1340 HWTEST_F(WindowManagerTest, NotifyDisplayInfoChange02, Function | SmallTest | Level2)
1341 {
1342     sptr<IRemoteObject> token = new (std::nothrow) IRemoteObjectMocker();
1343     ASSERT_NE(token, nullptr);
1344     WMError ret = WindowManager::GetInstance().NotifyDisplayInfoChange(token, 1, 2, DisplayOrientation::PORTRAIT);
1345     ASSERT_EQ(WMError::WM_OK, ret);
1346 }
1347 
1348 /**
1349  * @tc.name: NotifyWMSDisconnected01
1350  * @tc.desc: check NotifyWMSDisconnected
1351  * @tc.type: FUNC
1352  */
1353 HWTEST_F(WindowManagerTest, NotifyWMSDisconnected01, Function | SmallTest | Level2)
1354 {
1355     WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1356     ASSERT_NE(WMError::WM_OK, ret);
1357     WindowManager::GetInstance().pImpl_->NotifyWMSDisconnected(1, 2);
1358 }
1359 
1360 /**
1361  * @tc.name: NotifyFocused01
1362  * @tc.desc: check NotifyFocused
1363  * @tc.type: FUNC
1364  */
1365 HWTEST_F(WindowManagerTest, NotifyFocused01, Function | SmallTest | Level2)
1366 {
1367     sptr<FocusChangeInfo> focusChangeInfo = new FocusChangeInfo();
1368     ASSERT_NE(focusChangeInfo, nullptr);
1369 
1370     WindowManager::GetInstance().pImpl_->NotifyFocused(focusChangeInfo);
1371 }
1372 
1373 /**
1374  * @tc.name: NotifyUnfocused01
1375  * @tc.desc: check NotifyUnfocused
1376  * @tc.type: FUNC
1377  */
1378 HWTEST_F(WindowManagerTest, NotifyUnfocused01, Function | SmallTest | Level2)
1379 {
1380     sptr<FocusChangeInfo> focusChangeInfo = new FocusChangeInfo();
1381     ASSERT_NE(focusChangeInfo, nullptr);
1382 
1383     WindowManager::GetInstance().pImpl_->NotifyUnfocused(focusChangeInfo);
1384 }
1385 
1386 /**
1387  * @tc.name: NotifyAccessibilityWindowInfo01
1388  * @tc.desc: check NotifyAccessibilityWindowInfo
1389  * @tc.type: FUNC
1390  */
1391 HWTEST_F(WindowManagerTest, NotifyAccessibilityWindowInfo01, Function | SmallTest | Level2)
1392 {
1393     WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1394     ASSERT_NE(WMError::WM_OK, ret);
1395 
1396     std::vector<sptr<AccessibilityWindowInfo>> infos;
1397     WindowManager::GetInstance().pImpl_->NotifyAccessibilityWindowInfo(infos, WindowUpdateType::WINDOW_UPDATE_ACTIVE);
1398 
1399     infos.push_back(nullptr);
1400     WindowManager::GetInstance().pImpl_->NotifyAccessibilityWindowInfo(infos, WindowUpdateType::WINDOW_UPDATE_ACTIVE);
1401 }
1402 
1403 /**
1404  * @tc.name: NotifyVisibleWindowNumChanged01
1405  * @tc.desc: check NotifyVisibleWindowNumChanged
1406  * @tc.type: FUNC
1407  */
1408 HWTEST_F(WindowManagerTest, NotifyVisibleWindowNumChanged01, Function | SmallTest | Level2)
1409 {
1410     std::vector<VisibleWindowNumInfo> visibleWindowNumInfo;
1411     WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.clear();
1412     WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.push_back(nullptr);
1413     WindowManager::GetInstance().pImpl_->NotifyVisibleWindowNumChanged(visibleWindowNumInfo);
1414 
1415     sptr<IVisibleWindowNumChangedListener> listener = new (std::nothrow) TestVisibleWindowNumChangedListener();
1416     ASSERT_NE(listener, nullptr);
1417     WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.clear();
1418     WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.push_back(listener);
1419     WindowManager::GetInstance().pImpl_->NotifyVisibleWindowNumChanged(visibleWindowNumInfo);
1420 }
1421 
1422 /**
1423  * @tc.name: ReleaseForegroundSessionScreenLock
1424  * @tc.desc: check ReleaseForegroundSessionScreenLock
1425  * @tc.type: FUNC
1426  */
1427 HWTEST_F(WindowManagerTest, ReleaseForegroundSessionScreenLock, Function | SmallTest | Level2)
1428 {
1429     auto ret = WindowManager::GetInstance().ReleaseForegroundSessionScreenLock();
1430     ASSERT_EQ(ret, WMError::WM_OK);
1431 }
1432 
1433 /**
1434  * @tc.name: GetDisplayIdByWindowId
1435  * @tc.desc: check GetDisplayIdByWindowId
1436  * @tc.type: FUNC
1437  */
1438 HWTEST_F(WindowManagerTest, GetDisplayIdByWindowId, Function | SmallTest | Level2)
1439 {
1440     const std::vector<uint64_t> windowIds = {1, 2};
1441     std::unordered_map<uint64_t, DisplayId> windowDisplayIdMap;
1442     auto ret = WindowManager::GetInstance().GetDisplayIdByWindowId(windowIds, windowDisplayIdMap);
1443     ASSERT_EQ(WMError::WM_OK, ret);
1444 }
1445 
1446 /**
1447  * @tc.name: SetGlobalDragResizeType
1448  * @tc.desc: check SetGlobalDragResizeType
1449  * @tc.type: FUNC
1450  */
1451 HWTEST_F(WindowManagerTest, SetGlobalDragResizeType, Function | SmallTest | Level2)
1452 {
1453     DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1454     auto ret = WindowManager::GetInstance().SetGlobalDragResizeType(dragResizeType);
1455     ASSERT_EQ(WMError::WM_OK, ret);
1456 }
1457 
1458 /**
1459  * @tc.name: GetGlobalDragResizeType
1460  * @tc.desc: check GetGlobalDragResizeType
1461  * @tc.type: FUNC
1462  */
1463 HWTEST_F(WindowManagerTest, GetGlobalDragResizeType, Function | SmallTest | Level2)
1464 {
1465     DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1466     auto ret = WindowManager::GetInstance().GetGlobalDragResizeType(dragResizeType);
1467     ASSERT_EQ(WMError::WM_OK, ret);
1468 }
1469 
1470 /**
1471  * @tc.name: SetAppDragResizeType
1472  * @tc.desc: check SetAppDragResizeType
1473  * @tc.type: FUNC
1474  */
1475 HWTEST_F(WindowManagerTest, SetAppDragResizeType, Function | SmallTest | Level2)
1476 {
1477     DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1478     const std::string bundleName = "test";
1479     auto ret = WindowManager::GetInstance().SetAppDragResizeType(bundleName, dragResizeType);
1480     ASSERT_EQ(WMError::WM_OK, ret);
1481 }
1482 
1483 /**
1484  * @tc.name: GetAppDragResizeType
1485  * @tc.desc: check GetAppDragResizeType
1486  * @tc.type: FUNC
1487  */
1488 HWTEST_F(WindowManagerTest, GetAppDragResizeType, Function | SmallTest | Level2)
1489 {
1490     DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1491     const std::string bundleName = "test";
1492     auto ret = WindowManager::GetInstance().GetAppDragResizeType(bundleName, dragResizeType);
1493     ASSERT_EQ(WMError::WM_OK, ret);
1494 }
1495 }
1496 } // namespace Rosen
1497 } // namespace OHOS