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