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