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 #include "window_manager_hilog.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 namespace {
33 std::string g_errLog;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)34 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char *tag,
35 const char *msg)
36 {
37 g_errLog = msg;
38 }
39 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
40 class TestCameraFloatWindowChangedListener : public ICameraFloatWindowChangedListener {
41 public:
OnCameraFloatWindowChange(uint32_t accessTokenId,bool isShowing)42 void OnCameraFloatWindowChange(uint32_t accessTokenId, bool isShowing) override
43 {
44 WLOGI("TestCameraFloatWindowChangedListener [%{public}u, %{public}u]", accessTokenId, isShowing);
45 };
46 };
47
48 class TestVisibilityChangedListener : public IVisibilityChangedListener {
49 public:
OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>> & windowVisibilityInfo)50 void OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfo) override
51 {
52 WLOGI("TestVisibilityChangedListener");
53 };
54 };
55
56 class TestSystemBarChangedListener : public ISystemBarChangedListener {
57 public:
OnSystemBarPropertyChange(DisplayId displayId,const SystemBarRegionTints & tints)58 void OnSystemBarPropertyChange(DisplayId displayId, const SystemBarRegionTints& tints) override
59 {
60 WLOGI("TestSystemBarChangedListener");
61 };
62 };
63
64 class TestWindowSystemBarPropertyChangedListener : public IWindowSystemBarPropertyChangedListener {
65 public:
66 int32_t count_ = 0;
OnWindowSystemBarPropertyChanged(WindowType type,const SystemBarProperty & systemBarProperty)67 void OnWindowSystemBarPropertyChanged(WindowType type, const SystemBarProperty& systemBarProperty) override
68 {
69 count_ = 1;
70 TLOGI(WmsLogTag::WMS_IMMS, "TestSystemBarChangedListener");
71 }
72 };
73
74 class TestWindowUpdateListener : public IWindowUpdateListener {
75 public:
OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>> & infos,WindowUpdateType type)76 void OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>>& infos, WindowUpdateType type) override
77 {
78 WLOGI("TestWindowUpdateListener");
79 };
80 };
81
82 class TestWindowVisibilityStateListener : public IWindowInfoChangedListener {
83 public:
OnWindowInfoChanged(const std::vector<std::unordered_map<WindowInfoKey,WindowChangeInfoType>> & windowInfoList)84 void OnWindowInfoChanged(
85 const std::vector<std::unordered_map<WindowInfoKey, WindowChangeInfoType>>& windowInfoList) override
86 {
87 WLOGI("TestWindowUpdateListener");
88 };
89 };
90
91 class TestWindowDisplayIdChangeListener : public IWindowInfoChangedListener {
92 public:
OnWindowInfoChanged(const std::vector<std::unordered_map<WindowInfoKey,WindowChangeInfoType>> & windowInfoList)93 void OnWindowInfoChanged(
94 const std::vector<std::unordered_map<WindowInfoKey, WindowChangeInfoType>>& windowInfoList) override
95 {
96 TLOGI(WmsLogTag::WMS_ATTRIBUTE, "TestWindowDisplayIdChangeListener");
97 };
98 };
99
100 class TestWindowRectChangedListener : public IWindowInfoChangedListener {
101 public:
OnWindowInfoChanged(const std::vector<std::unordered_map<WindowInfoKey,WindowChangeInfoType>> & windowInfoList)102 void OnWindowInfoChanged(
103 const std::vector<std::unordered_map<WindowInfoKey, WindowChangeInfoType>>& windowInfoList) override
104 {
105 TLOGI(WmsLogTag::WMS_ATTRIBUTE, "TestWindowRectChangedListener");
106 };
107 };
108
109 class TestWindowModeChangedListenerForPropertyChange : public IWindowInfoChangedListener {
110 public:
111 int32_t count_ = 0;
112
OnWindowInfoChanged(const std::vector<std::unordered_map<WindowInfoKey,WindowChangeInfoType>> & windowInfoList)113 void OnWindowInfoChanged(
114 const std::vector<std::unordered_map<WindowInfoKey, WindowChangeInfoType>>& windowInfoList) override
115 {
116 TLOGI(WmsLogTag::WMS_ATTRIBUTE, "TestWindowModeChangedListenerForPropertyChange");
117 ++count_;
118 };
119 };
120
121 class TestFloatingScaleChangedListener : public IWindowInfoChangedListener {
122 public:
123 int32_t count_ = 0;
124
OnWindowInfoChanged(const std::vector<std::unordered_map<WindowInfoKey,WindowChangeInfoType>> & windowInfoList)125 void OnWindowInfoChanged(
126 const std::vector<std::unordered_map<WindowInfoKey, WindowChangeInfoType>>& windowInfoList) override
127 {
128 TLOGI(WmsLogTag::WMS_ATTRIBUTE, "TestFloatingScaleChangedListener");
129 ++count_;
130 };
131 };
132
133 class TestWindowModeChangedListener : public IWindowModeChangedListener {
134 public:
OnWindowModeUpdate(WindowModeType mode)135 void OnWindowModeUpdate(WindowModeType mode) override
136 {
137 WLOGI("TestWindowModeChangedListener");
138 };
139 };
140
141 class TestWaterMarkFlagChangeListener : public IWaterMarkFlagChangedListener {
142 public:
OnWaterMarkFlagUpdate(bool showWaterMark)143 void OnWaterMarkFlagUpdate(bool showWaterMark) override
144 {
145 WLOGI("TestWaterMarkFlagChangeListener");
146 };
147 };
148
149 class TestGestureNavigationEnabledChangedListener : public IGestureNavigationEnabledChangedListener {
150 public:
OnGestureNavigationEnabledUpdate(bool enable)151 void OnGestureNavigationEnabledUpdate(bool enable) override
152 {
153 WLOGI("TestGestureNavigationEnabledChangedListener");
154 };
155 };
156
157 class TestDisplayInfoChangedListener : public IDisplayInfoChangedListener {
158 public:
OnDisplayInfoChange(const sptr<IRemoteObject> & token,DisplayId displayId,float density,DisplayOrientation orientation)159 void OnDisplayInfoChange(const sptr<IRemoteObject>& token,
160 DisplayId displayId,
161 float density,
162 DisplayOrientation orientation) override
163 {
164 TLOGI(WmsLogTag::DMS, "TestDisplayInfoChangedListener");
165 }
166 };
167
168 class TestVisibleWindowNumChangedListener : public IVisibleWindowNumChangedListener {
169 public:
OnVisibleWindowNumChange(const std::vector<VisibleWindowNumInfo> & visibleWindowNumInfo)170 void OnVisibleWindowNumChange(const std::vector<VisibleWindowNumInfo>& visibleWindowNumInfo) override
171 {
172 for (const auto& num : visibleWindowNumInfo) {
173 GTEST_LOG_(INFO) << "displayId " << num.displayId << ", visibleWindowNum " << num.visibleWindowNum;
174 }
175 };
176 };
177
178 class TestDrawingContentChangedListener : public IDrawingContentChangedListener {
179 public:
OnWindowDrawingContentChanged(const std::vector<sptr<WindowDrawingContentInfo>> & windowDrawingInfo)180 void OnWindowDrawingContentChanged(const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingInfo)
181 {
182 TLOGI(WmsLogTag::DMS, "TestDrawingContentChangedListener");
183 }
184 };
185
186 class TestFocusChangedListener : public IFocusChangedListener {
187 public:
OnFocused(const sptr<FocusChangeInfo> & focusChangeInfo)188 void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo)
189 {
190 TLOGI(WmsLogTag::DMS, "TestFocusChangedListener OnFocused()");
191 }
OnUnfocused(const sptr<FocusChangeInfo> & focusChangeInfo)192 void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo)
193 {
194 TLOGI(WmsLogTag::DMS, "TestFocusChangedListener OnUnfocused()");
195 }
196 };
197
198 class TestWindowStyleChangedListener : public IWindowStyleChangedListener {
199 public:
OnWindowStyleUpdate(WindowStyleType styleType)200 void OnWindowStyleUpdate(WindowStyleType styleType)
201 {
202 TLOGI(WmsLogTag::DMS, "TestWindowStyleChangedListener");
203 }
204 };
205
206 class TestWindowPidVisibilityChangedListener : public IWindowPidVisibilityChangedListener {
207 public:
NotifyWindowPidVisibilityChanged(const sptr<WindowPidVisibilityInfo> & info)208 void NotifyWindowPidVisibilityChanged(const sptr<WindowPidVisibilityInfo>& info)
209 {
210 TLOGI(WmsLogTag::DMS, "TestWindowPidVisibilityChangedListener");
211 }
212 };
213
214 class TestIWindowLifeCycleListener : public IWindowLifeCycleListener {
215 public:
OnWindowDestroyed(const WindowLifeCycleInfo & lifeCycleInfo,void * jsWindowNapiValue)216 void OnWindowDestroyed(const WindowLifeCycleInfo& lifeCycleInfo, void* jsWindowNapiValue) override
217 {
218 listenerLifeCycleInfo.windowId = lifeCycleInfo.windowId;
219 listenerLifeCycleInfo.windowType = lifeCycleInfo.windowType;
220 listenerLifeCycleInfo.windowName = lifeCycleInfo.windowName;
221 }
222
TestIWindowLifeCycleListener()223 TestIWindowLifeCycleListener()
224 {
225 listenerLifeCycleInfo.windowId = 0;
226 listenerLifeCycleInfo.windowType = WindowType::SYSTEM_WINDOW_END;
227 listenerLifeCycleInfo.windowName = "";
228 }
229
230 WindowLifeCycleInfo listenerLifeCycleInfo;
231 };
232
233 class WindowManagerTest : public testing::Test {
234 public:
235 static void SetUpTestCase();
236 static void TearDownTestCase();
237 void SetUp() override;
238 void TearDown() override;
239 };
240
SetUpTestCase()241 void WindowManagerTest::SetUpTestCase() {}
242
TearDownTestCase()243 void WindowManagerTest::TearDownTestCase() {}
244
SetUp()245 void WindowManagerTest::SetUp() {}
246
TearDown()247 void WindowManagerTest::TearDown() {}
248
249 namespace {
250 /**
251 * @tc.name: Create01
252 * @tc.desc: Create window with no WindowName and no abilityToken
253 * @tc.type: FUNC
254 */
255 HWTEST_F(WindowManagerTest, GetVisibilityWindowInfo01, TestSize.Level1)
256 {
257 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
258 std::vector<sptr<WindowVisibilityInfo>> infos;
259 infos.clear();
260 EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
261 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetVisibilityWindowInfo(infos));
262 EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
263 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetVisibilityWindowInfo(infos));
264 }
265
266 /**
267 * @tc.name: ToggleShownStateForAllAppWindows
268 * @tc.desc: ToggleShownStateForAllAppWindows ok
269 * @tc.type: FUNC
270 */
271 HWTEST_F(WindowManagerTest, ToggleShownStateForAllAppWindows, TestSize.Level1)
272 {
273 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
274 EXPECT_CALL(m->Mock(), ToggleShownStateForAllAppWindows()).Times(1).WillOnce(Return(WMError::WM_OK));
275 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().ToggleShownStateForAllAppWindows());
276 }
277
278 /**
279 * @tc.name: Create01
280 * @tc.desc: Create window with no WindowName and no abilityToken
281 * @tc.type: FUNC
282 */
283 HWTEST_F(WindowManagerTest, GetAccessibilityWindowInfo01, TestSize.Level1)
284 {
285 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
286 std::vector<sptr<AccessibilityWindowInfo>> infos;
287 infos.clear();
288 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
289 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
290 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
291 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
292 }
293
294 /**
295 * @tc.name: GetUnreliableWindowInfo
296 * @tc.desc: GetUnreliableWindowInfo ok
297 * @tc.type: FUNC
298 */
299 HWTEST_F(WindowManagerTest, GetUnreliableWindowInfo, TestSize.Level1)
300 {
301 std::unique_ptr<Mocker> mocker = std::make_unique<Mocker>();
302 int32_t windowId = 0;
303 std::vector<sptr<UnreliableWindowInfo>> infos;
304 EXPECT_CALL(mocker->Mock(), GetUnreliableWindowInfo(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
305 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetUnreliableWindowInfo(windowId, infos));
306 }
307
308 /**
309 * @tc.name: GetSnapshotByWindowId01
310 * @tc.desc: Check GetSnapshotByWindowId01
311 * @tc.type: FUNC
312 */
313 HWTEST_F(WindowManagerTest, GetSnapshotByWindowId01, TestSize.Level1)
314 {
315 auto& windowManager = WindowManager::GetInstance();
316 int32_t windowId = -1;
317 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
318 WMError ret = windowManager.GetSnapshotByWindowId(windowId, pixelMap);
319 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
320 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
321 } else {
322 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
323 }
324 }
325
326 /**
327 * @tc.name: NotifyScreenshotEvent01
328 * @tc.desc: Check NotifyScreenshotEvent
329 * @tc.type: FUNC
330 */
331 HWTEST_F(WindowManagerTest, NotifyScreenshotEvent01, TestSize.Level1)
332 {
333 ScreenshotEventType type = ScreenshotEventType::SCROLL_SHOT_START;
334 auto& windowManager = WindowManager::GetInstance();
335 WMError ret = windowManager.NotifyScreenshotEvent(type);
336 EXPECT_EQ(ret, WMError::WM_OK);
337 }
338
339 /**
340 * @tc.name: RegisterCameraFloatWindowChangedListener01
341 * @tc.desc: check RegisterCameraFloatWindowChangedListener
342 * @tc.type: FUNC
343 */
344 HWTEST_F(WindowManagerTest, RegisterCameraFloatWindowChangedListener01, TestSize.Level1)
345 {
346 auto& windowManager = WindowManager::GetInstance();
347 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
348 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
349 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = nullptr;
350 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
351 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(nullptr));
352
353 sptr<TestCameraFloatWindowChangedListener> listener = sptr<TestCameraFloatWindowChangedListener>::MakeSptr();
354 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
355 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
356 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(listener));
357
358 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
359 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
360 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
361
362 // to check that the same listner can not be registered twice
363 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
364 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
365 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
366
367 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
368 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
369 }
370
371 /**
372 * @tc.name: UnregisterCameraFloatWindowChangedListener01
373 * @tc.desc: check UnregisterCameraFloatWindowChangedListener
374 * @tc.type: FUNC
375 */
376 HWTEST_F(WindowManagerTest, UnregisterCameraFloatWindowChangedListener01, TestSize.Level1)
377 {
378 auto& windowManager = WindowManager::GetInstance();
379 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
380 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
381 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
382 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
383
384 // check nullpter
385 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraFloatWindowChangedListener(nullptr));
386
387 sptr<TestCameraFloatWindowChangedListener> listener1 = sptr<TestCameraFloatWindowChangedListener>::MakeSptr();
388 sptr<TestCameraFloatWindowChangedListener> listener2 = sptr<TestCameraFloatWindowChangedListener>::MakeSptr();
389 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
390
391 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
392 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
393 windowManager.RegisterCameraFloatWindowChangedListener(listener1);
394 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
395 windowManager.RegisterCameraFloatWindowChangedListener(listener2);
396 ASSERT_EQ(2, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
397
398 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
399
400 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
401 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener2));
402 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
403 ASSERT_EQ(nullptr, windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_);
404
405 windowManager.pImpl_->cameraFloatWindowChangedListeners_.emplace_back(listener1);
406 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
407 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
408
409 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
410 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
411 }
412
413 /**
414 * @tc.name: RegisterVisibilityChangedListener01
415 * @tc.desc: check RegisterVisibilityChangedListener
416 * @tc.type: FUNC
417 */
418 HWTEST_F(WindowManagerTest, RegisterVisibilityChangedListener01, TestSize.Level1)
419 {
420 auto& windowManager = WindowManager::GetInstance();
421 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
422 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
423 windowManager.pImpl_->windowVisibilityListenerAgent_ = nullptr;
424 windowManager.pImpl_->windowVisibilityListeners_.clear();
425 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(nullptr));
426
427 sptr<TestVisibilityChangedListener> listener = sptr<TestVisibilityChangedListener>::MakeSptr();
428 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
429 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
430 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(listener));
431 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
432
433 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
434 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
435 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
436
437 // to check that the same listner can not be registered twice
438 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
439 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
440 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
441
442 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
443 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
444 }
445
446 /**
447 * @tc.name: UnregisterVisibilityChangedListener01
448 * @tc.desc: check UnregisterVisibilityChangedListener
449 * @tc.type: FUNC
450 */
451 HWTEST_F(WindowManagerTest, UnregisterVisibilityChangedListener01, TestSize.Level1)
452 {
453 auto& windowManager = WindowManager::GetInstance();
454 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
455 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
456 windowManager.pImpl_->windowVisibilityListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
457 windowManager.pImpl_->windowVisibilityListeners_.clear();
458
459 // check nullpter
460 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityChangedListener(nullptr));
461
462 sptr<TestVisibilityChangedListener> listener1 = sptr<TestVisibilityChangedListener>::MakeSptr();
463 sptr<TestVisibilityChangedListener> listener2 = sptr<TestVisibilityChangedListener>::MakeSptr();
464
465 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
466 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
467 windowManager.RegisterVisibilityChangedListener(listener1);
468 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
469 windowManager.RegisterVisibilityChangedListener(listener2);
470 ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityListeners_.size());
471
472 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
473 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
474 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener2));
475 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
476 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
477
478 windowManager.pImpl_->windowVisibilityListeners_.emplace_back(listener1);
479 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
480 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
481
482 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
483 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
484 }
485
486 /**
487 * @tc.name: RegisterWindowUpdateListener01
488 * @tc.desc: check RegisterWindowUpdateListener
489 * @tc.type: FUNC
490 */
491 HWTEST_F(WindowManagerTest, RegisterWindowUpdateListener01, TestSize.Level1)
492 {
493 auto& windowManager = WindowManager::GetInstance();
494 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
495 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
496 windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
497 windowManager.pImpl_->windowUpdateListeners_.clear();
498 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr));
499
500 sptr<TestWindowUpdateListener> listener = sptr<TestWindowUpdateListener>::MakeSptr();
501 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
502 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
503 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener));
504 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
505
506 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
507 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
508 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
509
510 // to check that the same listner can not be registered twice
511 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
512 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
513 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
514
515 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
516 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
517 }
518
519 /**
520 * @tc.name: UnregisterWindowUpdateListener01
521 * @tc.desc: check UnregisterWindowUpdateListener
522 * @tc.type: FUNC
523 */
524 HWTEST_F(WindowManagerTest, UnregisterWindowUpdateListener01, TestSize.Level1)
525 {
526 auto& windowManager = WindowManager::GetInstance();
527 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
528 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
529 windowManager.pImpl_->windowUpdateListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
530 windowManager.pImpl_->windowUpdateListeners_.clear();
531
532 // check nullpter
533 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr));
534
535 sptr<TestWindowUpdateListener> listener1 = sptr<TestWindowUpdateListener>::MakeSptr();
536 sptr<TestWindowUpdateListener> listener2 = sptr<TestWindowUpdateListener>::MakeSptr();
537 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
538
539 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
540 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
541 windowManager.RegisterWindowUpdateListener(listener1);
542 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
543 windowManager.RegisterWindowUpdateListener(listener2);
544 ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
545
546 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
547 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
548 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2));
549 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
550 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
551
552 windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
553 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
554 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
555
556 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
557 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
558 }
559
560 /**
561 * @tc.name: RegisterWindowModeChangedListener01
562 * @tc.desc: check RegisterWindowModeChangedListener
563 * @tc.type: FUNC
564 */
565 HWTEST_F(WindowManagerTest, RegisterWindowModeChangedListener01, TestSize.Level1)
566 {
567 auto& windowManager = WindowManager::GetInstance();
568 auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
569 auto oldListeners = windowManager.pImpl_->windowModeListeners_;
570 windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
571 windowManager.pImpl_->windowModeListeners_.clear();
572 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(nullptr));
573
574 sptr<TestWindowModeChangedListener> listener = sptr<TestWindowModeChangedListener>::MakeSptr();
575 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
576 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
577 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(listener));
578 ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
579
580 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
581 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
582 ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
583
584 // to check that the same listner can not be registered twice
585 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
586 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
587 ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
588
589 windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
590 windowManager.pImpl_->windowModeListeners_ = oldListeners;
591 }
592
593 /**
594 * @tc.name: UnregisterWindowModeChangedListener01
595 * @tc.desc: check UnregisterWindowModeChangedListener
596 * @tc.type: FUNC
597 */
598 HWTEST_F(WindowManagerTest, UnregisterWindowModeChangedListener01, TestSize.Level1)
599 {
600 auto& windowManager = WindowManager::GetInstance();
601 auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
602 auto oldListeners = windowManager.pImpl_->windowModeListeners_;
603 windowManager.pImpl_->windowModeListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
604 windowManager.pImpl_->windowModeListeners_.clear();
605
606 // check nullpter
607 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowModeChangedListener(nullptr));
608
609 sptr<TestWindowModeChangedListener> listener1 = sptr<TestWindowModeChangedListener>::MakeSptr();
610 sptr<TestWindowModeChangedListener> listener2 = sptr<TestWindowModeChangedListener>::MakeSptr();
611 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
612
613 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
614 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
615 windowManager.RegisterWindowModeChangedListener(listener1);
616 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
617 windowManager.RegisterWindowModeChangedListener(listener2);
618 ASSERT_EQ(2, windowManager.pImpl_->windowModeListeners_.size());
619
620 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
621 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
622 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener2));
623 ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
624 ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
625
626 windowManager.pImpl_->windowModeListeners_.emplace_back(listener1);
627 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
628 ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
629
630 windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
631 windowManager.pImpl_->windowModeListeners_ = oldListeners;
632 }
633
634 /**
635 * @tc.name: RegisterSystemBarChangedListener01
636 * @tc.desc: check RegisterSystemBarChangedListener
637 * @tc.type: FUNC
638 */
639 HWTEST_F(WindowManagerTest, RegisterSystemBarChangedListener01, TestSize.Level1)
640 {
641 auto& windowManager = WindowManager::GetInstance();
642 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
643 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
644 windowManager.pImpl_->systemBarChangedListenerAgent_ = nullptr;
645 windowManager.pImpl_->systemBarChangedListeners_.clear();
646 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(nullptr));
647
648 sptr<ISystemBarChangedListener> listener = sptr<TestSystemBarChangedListener>::MakeSptr();
649 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
650 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
651 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(listener));
652 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
653
654 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
655 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
656 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
657
658 // to check that the same listner can not be registered twice
659 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
660 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
661 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
662
663 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
664 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
665 }
666
667 /**
668 * @tc.name: UnregisterSystemBarChangedListener01
669 * @tc.desc: check UnregisterSystemBarChangedListener
670 * @tc.type: FUNC
671 */
672 HWTEST_F(WindowManagerTest, UnregisterSystemBarChangedListener01, TestSize.Level1)
673 {
674 auto& windowManager = WindowManager::GetInstance();
675 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
676 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
677 windowManager.pImpl_->systemBarChangedListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
678 windowManager.pImpl_->systemBarChangedListeners_.clear();
679 // check nullpter
680 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterSystemBarChangedListener(nullptr));
681
682 sptr<TestSystemBarChangedListener> listener1 = sptr<TestSystemBarChangedListener>::MakeSptr();
683 sptr<TestSystemBarChangedListener> listener2 = sptr<TestSystemBarChangedListener>::MakeSptr();
684 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
685
686 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
687 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
688 windowManager.RegisterSystemBarChangedListener(listener1);
689 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
690 windowManager.RegisterSystemBarChangedListener(listener2);
691 ASSERT_EQ(2, windowManager.pImpl_->systemBarChangedListeners_.size());
692
693 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
694 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
695 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener2));
696 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
697 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
698
699 windowManager.pImpl_->systemBarChangedListeners_.push_back(listener1);
700 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
701 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
702
703 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
704 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
705 }
706
707 /**
708 * @tc.name: RegisterWaterMarkListener01
709 * @tc.desc: check RegisterWaterMarkListener
710 * @tc.type: FUNC
711 */
712 HWTEST_F(WindowManagerTest, RegisterWaterMarkFlagChangedListener01, TestSize.Level1)
713 {
714 auto& windowManager = WindowManager::GetInstance();
715
716 windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
717 windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
718
719 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(nullptr));
720
721 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
722 sptr<TestWaterMarkFlagChangeListener> listener = sptr<TestWaterMarkFlagChangeListener>::MakeSptr();
723 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
724
725 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(listener));
726 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
727 ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
728
729 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
730 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
731 ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
732 ASSERT_NE(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
733
734 // to check that the same listner can not be registered twice
735 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
736 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
737 ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
738 }
739
740 /**
741 * @tc.name: UnregisterWaterMarkFlagChangedListener01
742 * @tc.desc: check UnregisterWaterMarkFlagChangedListener
743 * @tc.type: FUNC
744 */
745 HWTEST_F(WindowManagerTest, UnregisterWaterMarkFlagChangedListener01, TestSize.Level1)
746 {
747 auto& windowManager = WindowManager::GetInstance();
748 windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
749 windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
750 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
751
752 // check nullpter
753 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWaterMarkFlagChangedListener(nullptr));
754
755 sptr<TestWaterMarkFlagChangeListener> listener1 = sptr<TestWaterMarkFlagChangeListener>::MakeSptr();
756 sptr<TestWaterMarkFlagChangeListener> listener2 = sptr<TestWaterMarkFlagChangeListener>::MakeSptr();
757 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
758
759 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
760 windowManager.RegisterWaterMarkFlagChangedListener(listener1);
761 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
762 windowManager.RegisterWaterMarkFlagChangedListener(listener2);
763 ASSERT_EQ(2, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
764
765 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
766 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
767 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener2));
768 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
769 ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
770
771 // if agent == nullptr, it can not be crashed.
772 windowManager.pImpl_->waterMarkFlagChangeListeners_.push_back(listener1);
773 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
774 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
775 }
776
777 /**
778 * @tc.name: RegisterGestureNavigationEnabledChangedListener
779 * @tc.desc: check RegisterGestureNavigationEnabledChangedListener
780 * @tc.type: FUNC
781 */
782 HWTEST_F(WindowManagerTest, RegisterGestureNavigationEnabledChangedListener, TestSize.Level1)
783 {
784 auto& windowManager = WindowManager::GetInstance();
785
786 windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
787 windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
788
789 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(nullptr));
790
791 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
792 sptr<TestGestureNavigationEnabledChangedListener> listener =
793 sptr<TestGestureNavigationEnabledChangedListener>::MakeSptr();
794 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
795
796 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
797 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
798 ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
799
800 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
801 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
802 ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
803 ASSERT_NE(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
804
805 // to check that the same listner can not be registered twice
806 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
807 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
808 ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
809 }
810
811 /**
812 * @tc.name: UnregisterGestureNavigationEnabledChangedListener
813 * @tc.desc: check UnregisterGestureNavigationEnabledChangedListener
814 * @tc.type: FUNC
815 */
816 HWTEST_F(WindowManagerTest, UnregisterGestureNavigationEnabledChangedListener, TestSize.Level1)
817 {
818 auto& windowManager = WindowManager::GetInstance();
819 windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
820 windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
821 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
822
823 // check nullpter
824 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterGestureNavigationEnabledChangedListener(nullptr));
825
826 sptr<TestGestureNavigationEnabledChangedListener> listener1 =
827 sptr<TestGestureNavigationEnabledChangedListener>::MakeSptr();
828 sptr<TestGestureNavigationEnabledChangedListener> listener2 =
829 sptr<TestGestureNavigationEnabledChangedListener>::MakeSptr();
830 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM,
831 windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
832
833 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
834 windowManager.RegisterGestureNavigationEnabledChangedListener(listener1);
835 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
836 windowManager.RegisterGestureNavigationEnabledChangedListener(listener2);
837 ASSERT_EQ(2, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
838
839 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
840 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
841 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener2));
842 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
843 ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
844
845 // if agent == nullptr, it can not be crashed.
846 windowManager.pImpl_->gestureNavigationEnabledListeners_.push_back(listener1);
847 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
848 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
849 }
850
851 /**
852 * @tc.name: GetUIContentRemoteObj
853 * @tc.desc: GetUIContentRemoteObj
854 * @tc.type: FUNC
855 */
856 HWTEST_F(WindowManagerTest, GetUIContentRemoteObj, TestSize.Level1)
857 {
858 sptr<IRemoteObject> remoteObj;
859 WMError res = WindowManager::GetInstance().GetUIContentRemoteObj(1, remoteObj);
860 ASSERT_EQ(res, WMError::WM_OK);
861 }
862
863 /**
864 * @tc.name: GetFocusWindowInfo
865 * @tc.desc: window GetFocusWindowInfo
866 * @tc.type: FUNC
867 */
868 HWTEST_F(WindowManagerTest, GetFocusWindowInfo, TestSize.Level1)
869 {
870 FocusChangeInfo focusInfo;
871 DisplayId displayId = 0;
872 WindowManager::GetInstance().GetFocusWindowInfo(focusInfo, displayId);
873 WindowAdapter windowAdapter;
874
875 windowAdapter.GetFocusWindowInfo(focusInfo, displayId);
876 auto ret = windowAdapter.InitWMSProxy();
877 ASSERT_EQ(true, ret);
878 }
879
880 /**
881 * @tc.name: MinimizeAllAppWindows
882 * @tc.desc: window MinimizeAllAppWindows
883 * @tc.type: FUNC
884 */
885 HWTEST_F(WindowManagerTest, MinimizeAllAppWindows, TestSize.Level1)
886 {
887 DisplayId displayId = 0;
888 WMError ret = WindowManager::GetInstance().MinimizeAllAppWindows(displayId);
889 ASSERT_NE(ret, WMError::WM_OK);
890 }
891
892 /**
893 * @tc.name: SetWindowLayoutMode
894 * @tc.desc: window SetWindowLayoutMode
895 * @tc.type: FUNC
896 */
897 HWTEST_F(WindowManagerTest, SetWindowLayoutMode, TestSize.Level1)
898 {
899 WMError ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::BASE);
900 ASSERT_EQ(ret, WMError::WM_OK);
901
902 ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
903 ASSERT_EQ(ret, WMError::WM_OK);
904
905 ret = WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::END);
906 ASSERT_EQ(ret, WMError::WM_OK);
907 }
908
909 /**
910 * @tc.name: SkipSnapshotForAppProcess
911 * @tc.desc: check SkipSnapshotForAppProcess
912 * @tc.type: FUNC
913 */
914 HWTEST_F(WindowManagerTest, SkipSnapshotForAppProcess, TestSize.Level1)
915 {
916 int32_t pid = 1000;
917 bool skip = true;
918 auto ret = WindowManager::GetInstance().SkipSnapshotForAppProcess(pid, skip);
919 ASSERT_EQ(WMError::WM_OK, ret);
920 }
921
922 /**
923 * @tc.name: UpdateCameraFloatWindowStatus
924 * @tc.desc: UpdateCameraFloatWindowStatus
925 * @tc.type: FUNC
926 */
927 HWTEST_F(WindowManagerTest, UpdateCameraFloatWindowStatus, TestSize.Level1)
928 {
929 g_errLog.clear();
930 LOG_SetCallback(MyLogCallback);
931 uint32_t accessTokenId = 0;
932 bool isShowing = true;
933 WindowManager::GetInstance().UpdateCameraFloatWindowStatus(accessTokenId, isShowing);
934 EXPECT_FALSE(g_errLog.find("Camera float window, accessTokenId=%{private}u, isShowing=%{public}u")
935 != std::string::npos);
936 LOG_SetCallback(nullptr);
937 }
938
939 /**
940 * @tc.name: NotifyWaterMarkFlagChangedResult
941 * @tc.desc: NotifyWaterMarkFlagChangedResult
942 * @tc.type: FUNC
943 */
944 HWTEST_F(WindowManagerTest, NotifyWaterMarkFlagChangedResult, TestSize.Level1)
945 {
946 g_errLog.clear();
947 LOG_SetCallback(MyLogCallback);
948 bool showwatermark = true;
949 WindowManager::GetInstance().NotifyWaterMarkFlagChangedResult(showwatermark);
950 EXPECT_FALSE(g_errLog.find("Camera float window, accessTokenId=%{private}u, isShowing=%{public}u")
951 != std::string::npos);
952 LOG_SetCallback(nullptr);
953 }
954
955 /**
956 * @tc.name: NotifyGestureNavigationEnabledResult
957 * @tc.desc: NotifyGestureNavigationEnabledResult
958 * @tc.type: FUNC
959 */
960 HWTEST_F(WindowManagerTest, NotifyGestureNavigationEnabledResult, TestSize.Level1)
961 {
962 g_errLog.clear();
963 LOG_SetCallback(MyLogCallback);
964 bool enable = true;
965 WindowManager::GetInstance().NotifyGestureNavigationEnabledResult(enable);
966 EXPECT_FALSE(g_errLog.find("Notify gesture navigation enable result, enable=%{public}d")
967 != std::string::npos);
968 LOG_SetCallback(nullptr);
969 }
970
971 /**
972 * @tc.name: DumpSessionAll
973 * @tc.desc: DumpSessionAll
974 * @tc.type: FUNC
975 */
976 HWTEST_F(WindowManagerTest, DumpSessionAll, TestSize.Level1)
977 {
978 std::vector<std::string> infos;
979 infos.push_back("DumpSessionWithId");
980 WMError res = WindowManager::GetInstance().DumpSessionAll(infos);
981 ASSERT_EQ(WMError::WM_OK, res);
982 }
983
984 /**
985 * @tc.name: DumpSessionWithId
986 * @tc.desc: DumpSessionWithId
987 * @tc.type: FUNC
988 */
989 HWTEST_F(WindowManagerTest, DumpSessionWithId, TestSize.Level1)
990 {
991 std::vector<std::string> infos;
992 infos.push_back("DumpSessionWithId");
993 int32_t persistentId = 0;
994 WMError res = WindowManager::GetInstance().DumpSessionWithId(persistentId, infos);
995 ASSERT_EQ(WMError::WM_OK, res);
996 }
997
998 /**
999 * @tc.name: GetWindowModeType01
1000 * @tc.desc: GetWindowModeType01
1001 * @tc.type: FUNC
1002 */
1003 HWTEST_F(WindowManagerTest, GetWindowModeType01, TestSize.Level1)
1004 {
1005 std::vector<sptr<AccessibilityWindowInfo>> infos;
1006 infos.clear();
1007 WindowModeType windowModeType;
1008 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1009 EXPECT_CALL(m->Mock(), GetWindowModeType(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1010 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetWindowModeType(windowModeType));
1011 }
1012
1013 /**
1014 * @tc.name: RegisterVisibleWindowNumChangedListener
1015 * @tc.desc: check RegisterVisibleWindowNumChangedListener
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(WindowManagerTest, RegisterVisibleWindowNumChangedListener, TestSize.Level1)
1019 {
1020 auto& windowManager = WindowManager::GetInstance();
1021
1022 windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
1023 windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
1024
1025 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibleWindowNumChangedListener(nullptr));
1026
1027 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1028 sptr<TestVisibleWindowNumChangedListener> listener = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
1029 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1030
1031 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibleWindowNumChangedListener(listener));
1032 ASSERT_EQ(0, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
1033 ASSERT_EQ(nullptr, windowManager.pImpl_->visibleWindowNumChangedListenerAgent_);
1034
1035 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1036 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
1037 ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
1038 ASSERT_NE(nullptr, windowManager.pImpl_->visibleWindowNumChangedListenerAgent_);
1039
1040 // to check that the same listner can not be registered twice
1041 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1042 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
1043 ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
1044 }
1045
1046 /**
1047 * @tc.name: UnregisterVisibleWindowNumChangedListener
1048 * @tc.desc: check UnregisterVisibleWindowNumChangedListener
1049 * @tc.type: FUNC
1050 */
1051 HWTEST_F(WindowManagerTest, UnregisterVisibleWindowNumChangedListener, TestSize.Level1)
1052 {
1053 auto& windowManager = WindowManager::GetInstance();
1054 windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
1055 windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
1056 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1057
1058 // check nullpter
1059 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibleWindowNumChangedListener(nullptr));
1060
1061 sptr<TestVisibleWindowNumChangedListener> listener1 = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
1062 sptr<TestVisibleWindowNumChangedListener> listener2 = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
1063
1064 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1065 windowManager.RegisterVisibleWindowNumChangedListener(listener1);
1066 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1067 windowManager.RegisterVisibleWindowNumChangedListener(listener2);
1068 ASSERT_EQ(2, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
1069
1070 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener1));
1071 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener2));
1072 ASSERT_EQ(2, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
1073
1074 // if agent == nullptr, it can not be crashed.
1075 windowManager.pImpl_->visibleWindowNumChangedListeners_.push_back(listener1);
1076 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener1));
1077 ASSERT_EQ(3, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
1078 }
1079
1080 /**
1081 * @tc.name: RegisterAndOnVisibleWindowNumChanged
1082 * @tc.desc: check RegisterAndOnVisibleWindowNumChanged
1083 * @tc.type: FUNC
1084 */
1085 HWTEST_F(WindowManagerTest, RegisterAndOnVisibleWindowNumChanged, TestSize.Level1)
1086 {
1087 auto& windowManager = WindowManager::GetInstance();
1088 windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
1089 windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
1090
1091 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1092 sptr<TestVisibleWindowNumChangedListener> listener = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
1093 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1094 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
1095 ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
1096
1097 std::vector<VisibleWindowNumInfo> visibleWindowNumInfo;
1098 VisibleWindowNumInfo newInfo;
1099 newInfo.displayId = 0;
1100 newInfo.visibleWindowNum = 2;
1101 visibleWindowNumInfo.push_back(newInfo);
1102 windowManager.UpdateVisibleWindowNum(visibleWindowNumInfo);
1103 }
1104
1105 /**
1106 * @tc.name: Test01
1107 * @tc.desc: Test01
1108 * @tc.type: FUNC
1109 */
1110 HWTEST_F(WindowManagerTest, Test01, TestSize.Level1)
1111 {
1112 sptr<IWMSConnectionChangedListener> listener = nullptr;
1113 WMError res = WindowManager::GetInstance().RegisterWMSConnectionChangedListener(listener);
1114 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, res);
1115 WMError res1 = WindowManager::GetInstance().UnregisterWMSConnectionChangedListener();
1116 ASSERT_EQ(WMError::WM_OK, res1);
1117 WindowManager::GetInstance().RaiseWindowToTop(5);
1118 WMError res3 = WindowManager::GetInstance().NotifyWindowExtensionVisibilityChange(5, 5, true);
1119 ASSERT_EQ(WMError::WM_OK, res3);
1120 WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1121 }
1122
1123 /**
1124 * @tc.name: RegisterDisplayInfoChangedListener
1125 * @tc.desc: check RegisterDisplayInfoChangedListener
1126 * @tc.type: FUNC
1127 */
1128 HWTEST_F(WindowManagerTest, RegisterDisplayInfoChangedListener, TestSize.Level1)
1129 {
1130 auto& windowManager = WindowManager::GetInstance();
1131 windowManager.pImpl_->displayInfoChangedListeners_.clear();
1132
1133 sptr<IRemoteObject> targetToken = nullptr;
1134 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(targetToken, nullptr));
1135
1136 targetToken = sptr<IRemoteObjectMocker>::MakeSptr();
1137 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(targetToken, nullptr));
1138
1139 sptr<IDisplayInfoChangedListener> listener = sptr<TestDisplayInfoChangedListener>::MakeSptr();
1140 sptr<IDisplayInfoChangedListener> listener2 = sptr<TestDisplayInfoChangedListener>::MakeSptr();
1141
1142 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(nullptr, listener));
1143 ASSERT_EQ(0, windowManager.pImpl_->displayInfoChangedListeners_.size());
1144 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
1145 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1146
1147 // to check that the same listner can not be registered twice
1148 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
1149 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1150
1151 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener2));
1152 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1153 auto iter = windowManager.pImpl_->displayInfoChangedListeners_.find(targetToken);
1154 ASSERT_NE(windowManager.pImpl_->displayInfoChangedListeners_.end(), iter);
1155 ASSERT_EQ(2, iter->second.size());
1156 }
1157
1158 /**
1159 * @tc.name: UnregisterDisplayInfoChangedListener
1160 * @tc.desc: check UnregisterDisplayInfoChangedListener
1161 * @tc.type: FUNC
1162 */
1163 HWTEST_F(WindowManagerTest, UnregisterDisplayInfoChangedListener, TestSize.Level1)
1164 {
1165 auto& windowManager = WindowManager::GetInstance();
1166 windowManager.pImpl_->displayInfoChangedListeners_.clear();
1167
1168 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(nullptr, nullptr));
1169
1170 sptr<IRemoteObject> targetToken = sptr<IRemoteObjectMocker>::MakeSptr();
1171 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(targetToken, nullptr));
1172
1173 sptr<IDisplayInfoChangedListener> listener = sptr<TestDisplayInfoChangedListener>::MakeSptr();
1174 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayInfoChangedListener(nullptr, listener));
1175
1176 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener));
1177
1178 sptr<IRemoteObject> targetToken2 = sptr<IRemoteObjectMocker>::MakeSptr();
1179 sptr<IDisplayInfoChangedListener> listener2 = sptr<TestDisplayInfoChangedListener>::MakeSptr();
1180
1181 // the same token can have multiple listeners
1182 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
1183 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1184 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener2));
1185 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1186 auto iter = windowManager.pImpl_->displayInfoChangedListeners_.find(targetToken);
1187 ASSERT_NE(windowManager.pImpl_->displayInfoChangedListeners_.end(), iter);
1188 ASSERT_EQ(2, iter->second.size());
1189
1190 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken2, listener));
1191 ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size());
1192
1193 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener));
1194 ASSERT_EQ(1, iter->second.size());
1195 ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size());
1196
1197 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken, listener2));
1198 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1199 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayInfoChangedListener(targetToken2, listener));
1200 ASSERT_EQ(0, windowManager.pImpl_->displayInfoChangedListeners_.size());
1201 }
1202
1203 /**
1204 * @tc.name: NotifyDisplayInfoChanged
1205 * @tc.desc: check NotifyDisplayInfoChanged
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(WindowManagerTest, NotifyDisplayInfoChanged, TestSize.Level1)
1209 {
1210 sptr<IRemoteObject> targetToken = sptr<IRemoteObjectMocker>::MakeSptr();
1211 DisplayId displayId = 0;
1212 float density = 0.2f;
1213 DisplayOrientation orientation = DisplayOrientation::UNKNOWN;
1214
1215 auto& windowManager = WindowManager::GetInstance();
1216 windowManager.pImpl_->displayInfoChangedListeners_.clear();
1217 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation);
1218
1219 sptr<IRemoteObject> targetToken2 = sptr<IRemoteObjectMocker>::MakeSptr();
1220 sptr<IDisplayInfoChangedListener> listener = sptr<TestDisplayInfoChangedListener>::MakeSptr();
1221
1222 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
1223 ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
1224 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation);
1225
1226 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken2, listener));
1227 ASSERT_EQ(2, windowManager.pImpl_->displayInfoChangedListeners_.size());
1228 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation);
1229 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken2, displayId, density, orientation);
1230 // no repeated notification is sent if parameters do not change
1231 windowManager.pImpl_->NotifyDisplayInfoChanged(targetToken, displayId, density, orientation);
1232 }
1233
1234 /**
1235 * @tc.name: RegisterWindowStyleChangedListener
1236 * @tc.desc: check RegisterWindowStyleChangedListener
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(WindowManagerTest, RegisterWindowStyleChangedListener, TestSize.Level1)
1240 {
1241 auto& windowManager = WindowManager::GetInstance();
1242 auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
1243 auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
1244 windowManager.pImpl_->windowStyleListenerAgent_ = nullptr;
1245 windowManager.pImpl_->windowStyleListeners_.clear();
1246 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(nullptr));
1247
1248 sptr<IWindowStyleChangedListener> listener = sptr<TestWindowStyleChangedListener>::MakeSptr();
1249 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1250 }
1251
1252 /**
1253 * @tc.name: UnregisterWindowStyleChangedListener
1254 * @tc.desc: check UnregisterWindowStyleChangedListener
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_F(WindowManagerTest, UnregisterWindowStyleChangedListener, TestSize.Level1)
1258 {
1259 auto& windowManager = WindowManager::GetInstance();
1260 auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
1261 auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
1262 windowManager.pImpl_->windowStyleListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
1263 windowManager.pImpl_->windowStyleListeners_.clear();
1264 // check nullpter
1265 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowStyleChangedListener(nullptr));
1266
1267 sptr<TestWindowStyleChangedListener> listener1 = sptr<TestWindowStyleChangedListener>::MakeSptr();
1268 sptr<TestWindowStyleChangedListener> listener2 = sptr<TestWindowStyleChangedListener>::MakeSptr();
1269 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
1270 }
1271
1272 /**
1273 * @tc.name: NotifyWindowStyleChange
1274 * @tc.desc: check NotifyWindowStyleChange
1275 * @tc.type: FUNC
1276 */
1277 HWTEST_F(WindowManagerTest, NotifyWindowStyleChange, TestSize.Level1)
1278 {
1279 WindowStyleType type = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
1280 auto ret = WindowManager::GetInstance().NotifyWindowStyleChange(type);
1281 ASSERT_EQ(WMError::WM_OK, ret);
1282 }
1283
1284 /**
1285 * @tc.name: GetWindowStyleType
1286 * @tc.desc: check GetWindowStyleType
1287 * @tc.type: FUNC
1288 */
1289 HWTEST_F(WindowManagerTest, GetWindowStyleType, TestSize.Level1)
1290 {
1291 WindowStyleType type;
1292 type = WindowManager::GetInstance().GetWindowStyleType();
1293 ASSERT_EQ(Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT, type);
1294 }
1295
1296 /**
1297 * @tc.name: ShiftAppWindowFocus01
1298 * @tc.desc: check ShiftAppWindowFocus
1299 * @tc.type: FUNC
1300 */
1301 HWTEST_F(WindowManagerTest, ShiftAppWindowFocus01, TestSize.Level1)
1302 {
1303 WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1304 ASSERT_NE(WMError::WM_OK, ret);
1305 }
1306
1307 /**
1308 * @tc.name: RegisterVisibleWindowNumChangedListener01
1309 * @tc.desc: check RegisterVisibleWindowNumChangedListener
1310 * @tc.type: FUNC
1311 */
1312 HWTEST_F(WindowManagerTest, RegisterVisibleWindowNumChangedListener01, TestSize.Level1)
1313 {
1314 WMError ret;
1315 sptr<IVisibleWindowNumChangedListener> listener = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
1316 ret = WindowManager::GetInstance().RegisterVisibleWindowNumChangedListener(listener);
1317 ASSERT_NE(WMError::WM_OK, ret);
1318
1319 ret = WindowManager::GetInstance().RegisterVisibleWindowNumChangedListener(nullptr);
1320 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1321 }
1322
1323 /**
1324 * @tc.name: UnregisterVisibleWindowNumChangedListener01
1325 * @tc.desc: check UnregisterVisibleWindowNumChangedListener
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(WindowManagerTest, UnregisterVisibleWindowNumChangedListener01, TestSize.Level1)
1329 {
1330 WMError ret;
1331 sptr<IVisibleWindowNumChangedListener> listener = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
1332 ret = WindowManager::GetInstance().UnregisterVisibleWindowNumChangedListener(listener);
1333 ASSERT_EQ(WMError::WM_OK, ret);
1334
1335 ret = WindowManager::GetInstance().UnregisterVisibleWindowNumChangedListener(nullptr);
1336 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1337 }
1338
1339 /**
1340 * @tc.name: RegisterDrawingContentChangedListener01
1341 * @tc.desc: check RegisterDrawingContentChangedListener
1342 * @tc.type: FUNC
1343 */
1344 HWTEST_F(WindowManagerTest, RegisterDrawingContentChangedListener01, TestSize.Level1)
1345 {
1346 WMError ret;
1347 sptr<IDrawingContentChangedListener> listener = sptr<TestDrawingContentChangedListener>::MakeSptr();
1348 ret = WindowManager::GetInstance().RegisterDrawingContentChangedListener(listener);
1349 ASSERT_NE(WMError::WM_OK, ret);
1350
1351 ret = WindowManager::GetInstance().RegisterDrawingContentChangedListener(nullptr);
1352 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1353 }
1354
1355 /**
1356 * @tc.name: UnregisterDrawingContentChangedListener01
1357 * @tc.desc: check UnregisterDrawingContentChangedListener
1358 * @tc.type: FUNC
1359 */
1360 HWTEST_F(WindowManagerTest, UnregisterDrawingContentChangedListener01, TestSize.Level1)
1361 {
1362 WMError ret;
1363 sptr<IDrawingContentChangedListener> listener = sptr<TestDrawingContentChangedListener>::MakeSptr();
1364 ret = WindowManager::GetInstance().UnregisterDrawingContentChangedListener(listener);
1365 ASSERT_EQ(WMError::WM_OK, ret);
1366
1367 ret = WindowManager::GetInstance().UnregisterDrawingContentChangedListener(nullptr);
1368 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1369 }
1370
1371 /**
1372 * @tc.name: RegisterFocusChangedListener01
1373 * @tc.desc: check RegisterFocusChangedListener
1374 * @tc.type: FUNC
1375 */
1376 HWTEST_F(WindowManagerTest, RegisterFocusChangedListener01, TestSize.Level1)
1377 {
1378 WMError ret;
1379 sptr<IFocusChangedListener> listener = sptr<TestFocusChangedListener>::MakeSptr();
1380 ret = WindowManager::GetInstance().RegisterFocusChangedListener(listener);
1381 ASSERT_NE(WMError::WM_OK, ret);
1382
1383 ret = WindowManager::GetInstance().RegisterFocusChangedListener(nullptr);
1384 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1385 }
1386
1387 /**
1388 * @tc.name: UnregisterFocusChangedListener01
1389 * @tc.desc: check UnregisterFocusChangedListener
1390 * @tc.type: FUNC
1391 */
1392 HWTEST_F(WindowManagerTest, UnregisterFocusChangedListener01, TestSize.Level1)
1393 {
1394 WMError ret;
1395 sptr<IFocusChangedListener> listener = sptr<TestFocusChangedListener>::MakeSptr();
1396 ret = WindowManager::GetInstance().UnregisterFocusChangedListener(listener);
1397 ASSERT_EQ(WMError::WM_OK, ret);
1398
1399 ret = WindowManager::GetInstance().UnregisterFocusChangedListener(nullptr);
1400 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1401 }
1402
1403 /**
1404 * @tc.name: SetProcessWatermark
1405 * @tc.desc: check SetProcessWatermark
1406 * @tc.type: FUNC
1407 */
1408 HWTEST_F(WindowManagerTest, SetProcessWatermark, TestSize.Level1)
1409 {
1410 int32_t pid = 1000;
1411 const std::string watermarkName = "SetProcessWatermarkName";
1412 bool isEnabled = true;
1413 auto ret = WindowManager::GetInstance().SetProcessWatermark(pid, watermarkName, isEnabled);
1414 ASSERT_EQ(WMError::WM_OK, ret);
1415 }
1416
1417 /**
1418 * @tc.name: NotifyDisplayInfoChange01
1419 * @tc.desc: check NotifyDisplayInfoChange, Token is nullptr
1420 * @tc.type: FUNC
1421 */
1422 HWTEST_F(WindowManagerTest, NotifyDisplayInfoChange01, TestSize.Level1)
1423 {
1424 WMError ret = WindowManager::GetInstance().NotifyDisplayInfoChange(nullptr, 1, 2, DisplayOrientation::PORTRAIT);
1425 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1426 }
1427
1428 /**
1429 * @tc.name: NotifyDisplayInfoChange02
1430 * @tc.desc: check NotifyDisplayInfoChange, Token is nullptr
1431 * @tc.type: FUNC
1432 */
1433 HWTEST_F(WindowManagerTest, NotifyDisplayInfoChange02, TestSize.Level1)
1434 {
1435 sptr<IRemoteObject> Token = sptr<IRemoteObjectMocker>::MakeSptr();
1436 WMError ret = WindowManager::GetInstance().NotifyDisplayInfoChange(Token, 1, 2, DisplayOrientation::PORTRAIT);
1437 ASSERT_EQ(WMError::WM_OK, ret);
1438 }
1439
1440 /**
1441 * @tc.name: NotifyWMSDisconnected01
1442 * @tc.desc: check NotifyWMSDisconnected
1443 * @tc.type: FUNC
1444 */
1445 HWTEST_F(WindowManagerTest, NotifyWMSDisconnected01, TestSize.Level1)
1446 {
1447 WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1448 ASSERT_NE(WMError::WM_OK, ret);
1449 WindowManager::GetInstance().pImpl_->NotifyWMSDisconnected(1, 2);
1450 }
1451
1452 /**
1453 * @tc.name: NotifyFocused01
1454 * @tc.desc: check NotifyFocused
1455 * @tc.type: FUNC
1456 */
1457 HWTEST_F(WindowManagerTest, NotifyFocused01, TestSize.Level1)
1458 {
1459 sptr<FocusChangeInfo> focusChangeInfo = sptr<FocusChangeInfo>::MakeSptr();
1460 ASSERT_NE(focusChangeInfo, nullptr);
1461
1462 WindowManager::GetInstance().pImpl_->NotifyFocused(focusChangeInfo);
1463 }
1464
1465 /**
1466 * @tc.name: NotifyUnfocused01
1467 * @tc.desc: check NotifyUnfocused
1468 * @tc.type: FUNC
1469 */
1470 HWTEST_F(WindowManagerTest, NotifyUnfocused01, TestSize.Level1)
1471 {
1472 sptr<FocusChangeInfo> focusChangeInfo = sptr<FocusChangeInfo>::MakeSptr();
1473 ASSERT_NE(focusChangeInfo, nullptr);
1474
1475 WindowManager::GetInstance().pImpl_->NotifyUnfocused(focusChangeInfo);
1476 }
1477
1478 /**
1479 * @tc.name: NotifyAccessibilityWindowInfo01
1480 * @tc.desc: check NotifyAccessibilityWindowInfo
1481 * @tc.type: FUNC
1482 */
1483 HWTEST_F(WindowManagerTest, NotifyAccessibilityWindowInfo01, TestSize.Level1)
1484 {
1485 WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1486 ASSERT_NE(WMError::WM_OK, ret);
1487 sptr<AccessibilityWindowInfo> info = sptr<AccessibilityWindowInfo>::MakeSptr();
1488 ASSERT_NE(info, nullptr);
1489
1490 std::vector<sptr<AccessibilityWindowInfo>> infos;
1491 infos.push_back(info);
1492 WindowManager::GetInstance().pImpl_->NotifyAccessibilityWindowInfo(infos, WindowUpdateType::WINDOW_UPDATE_ACTIVE);
1493
1494 infos.clear();
1495 infos.push_back(nullptr);
1496 WindowManager::GetInstance().pImpl_->NotifyAccessibilityWindowInfo(infos, WindowUpdateType::WINDOW_UPDATE_ACTIVE);
1497 }
1498
1499 /**
1500 * @tc.name: NotifyVisibleWindowNumChanged01
1501 * @tc.desc: check NotifyVisibleWindowNumChanged
1502 * @tc.type: FUNC
1503 */
1504 HWTEST_F(WindowManagerTest, NotifyVisibleWindowNumChanged01, TestSize.Level1)
1505 {
1506 std::vector<VisibleWindowNumInfo> visibleWindowNumInfo;
1507 WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.clear();
1508 WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.push_back(nullptr);
1509 WindowManager::GetInstance().pImpl_->NotifyVisibleWindowNumChanged(visibleWindowNumInfo);
1510
1511 sptr<IVisibleWindowNumChangedListener> listener = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
1512 ASSERT_NE(listener, nullptr);
1513 WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.clear();
1514 WindowManager::GetInstance().pImpl_->visibleWindowNumChangedListeners_.push_back(listener);
1515 WindowManager::GetInstance().pImpl_->NotifyVisibleWindowNumChanged(visibleWindowNumInfo);
1516 }
1517
1518 /**
1519 * @tc.name: RegisterWindowPidVisibilityChangedListener
1520 * @tc.desc: check RegisterWindowPidVisibilityChangedListener
1521 * @tc.type: FUNC
1522 */
1523 HWTEST_F(WindowManagerTest, RegisterWindowPidVisibilityChangedListener, TestSize.Level1)
1524 {
1525 WMError ret;
1526 sptr<IWindowPidVisibilityChangedListener> listener = sptr<TestWindowPidVisibilityChangedListener>::MakeSptr();
1527 ASSERT_NE(nullptr, listener);
1528 ret = WindowManager::GetInstance().RegisterWindowPidVisibilityChangedListener(listener);
1529 ASSERT_EQ(WMError::WM_OK, ret);
1530
1531 ret = WindowManager::GetInstance().RegisterWindowPidVisibilityChangedListener(nullptr);
1532 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1533 }
1534
1535 /**
1536 * @tc.name: UnregisterWindowPidVisibilityChangedListener
1537 * @tc.desc: check UnregisterWindowPidVisibilityChangedListener
1538 * @tc.type: FUNC
1539 */
1540 HWTEST_F(WindowManagerTest, UnregisterWindowPidVisibilityChangedListener, TestSize.Level1)
1541 {
1542 WMError ret;
1543 sptr<IWindowPidVisibilityChangedListener> listener = sptr<TestWindowPidVisibilityChangedListener>::MakeSptr();
1544 ret = WindowManager::GetInstance().UnregisterWindowPidVisibilityChangedListener(listener);
1545 ASSERT_EQ(WMError::WM_OK, ret);
1546
1547 ret = WindowManager::GetInstance().UnregisterWindowPidVisibilityChangedListener(nullptr);
1548 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1549 }
1550
1551 /**
1552 * @tc.name: NotifyWindowPidVisibilityChanged
1553 * @tc.desc: NotifyWindowPidVisibilityChanged
1554 * @tc.type: FUNC
1555 */
1556 HWTEST_F(WindowManagerTest, NotifyWindowPidVisibilityChanged, TestSize.Level1)
1557 {
1558 sptr<WindowPidVisibilityInfo> info = sptr<WindowPidVisibilityInfo>::MakeSptr();
1559 WindowManager::GetInstance().NotifyWindowPidVisibilityChanged(info);
1560 ASSERT_NE(info, nullptr);
1561 }
1562
1563 /**
1564 * @tc.name: UpdateScreenLockStatusForApp
1565 * @tc.desc: check UpdateScreenLockStatusForApp
1566 * @tc.type: FUNC
1567 */
1568 HWTEST_F(WindowManagerTest, UpdateScreenLockStatusForApp, TestSize.Level1)
1569 {
1570 auto ret = WindowManager::GetInstance().UpdateScreenLockStatusForApp("", true);
1571 ASSERT_EQ(ret, WMError::WM_OK);
1572 }
1573
1574 /**
1575 * @tc.name: GetDisplayIdByWindowId
1576 * @tc.desc: check GetDisplayIdByWindowId
1577 * @tc.type: FUNC
1578 */
1579 HWTEST_F(WindowManagerTest, GetDisplayIdByWindowId, TestSize.Level1)
1580 {
1581 const std::vector<uint64_t> windowIds = { 1, 2 };
1582 std::unordered_map<uint64_t, DisplayId> windowDisplayIdMap;
1583 auto ret = WindowManager::GetInstance().GetDisplayIdByWindowId(windowIds, windowDisplayIdMap);
1584 ASSERT_EQ(WMError::WM_OK, ret);
1585 }
1586
1587 /**
1588 * @tc.name: SetGlobalDragResizeType
1589 * @tc.desc: check SetGlobalDragResizeType
1590 * @tc.type: FUNC
1591 */
1592 HWTEST_F(WindowManagerTest, SetGlobalDragResizeType, TestSize.Level1)
1593 {
1594 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1595 auto ret = WindowManager::GetInstance().SetGlobalDragResizeType(dragResizeType);
1596 ASSERT_EQ(WMError::WM_OK, ret);
1597 }
1598
1599 /**
1600 * @tc.name: GetGlobalDragResizeType
1601 * @tc.desc: check GetGlobalDragResizeType
1602 * @tc.type: FUNC
1603 */
1604 HWTEST_F(WindowManagerTest, GetGlobalDragResizeType, TestSize.Level1)
1605 {
1606 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1607 auto ret = WindowManager::GetInstance().GetGlobalDragResizeType(dragResizeType);
1608 ASSERT_EQ(WMError::WM_OK, ret);
1609 }
1610
1611 /**
1612 * @tc.name: SetAppDragResizeType
1613 * @tc.desc: check SetAppDragResizeType
1614 * @tc.type: FUNC
1615 */
1616 HWTEST_F(WindowManagerTest, SetAppDragResizeType, TestSize.Level1)
1617 {
1618 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1619 const std::string bundleName = "test";
1620 auto ret = WindowManager::GetInstance().SetAppDragResizeType(bundleName, dragResizeType);
1621 ASSERT_EQ(WMError::WM_OK, ret);
1622 }
1623
1624 /**
1625 * @tc.name: GetAppDragResizeType
1626 * @tc.desc: check GetAppDragResizeType
1627 * @tc.type: FUNC
1628 */
1629 HWTEST_F(WindowManagerTest, GetAppDragResizeType, TestSize.Level1)
1630 {
1631 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1632 const std::string bundleName = "test";
1633 auto ret = WindowManager::GetInstance().GetAppDragResizeType(bundleName, dragResizeType);
1634 ASSERT_EQ(WMError::WM_OK, ret);
1635 }
1636
1637 /**
1638 * @tc.name: EffectiveDragResizeType
1639 * @tc.desc: test EffectiveDragResizeType
1640 * @tc.type: FUNC
1641 */
1642 HWTEST_F(WindowManagerTest, EffectiveDragResizeType, TestSize.Level1)
1643 {
1644 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1645 const std::string bundleName = "test";
1646
1647 DragResizeType globalDragResizeType = DragResizeType::RESIZE_WHEN_DRAG_END;
1648 DragResizeType appDragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1649 WindowManager::GetInstance().SetGlobalDragResizeType(globalDragResizeType);
1650 WindowManager::GetInstance().SetAppDragResizeType(bundleName, appDragResizeType);
1651 WindowManager::GetInstance().GetAppDragResizeType(bundleName, dragResizeType);
1652 ASSERT_EQ(dragResizeType, globalDragResizeType);
1653 WindowManager::GetInstance().SetGlobalDragResizeType(DragResizeType::RESIZE_TYPE_UNDEFINED);
1654 WindowManager::GetInstance().GetAppDragResizeType(bundleName, dragResizeType);
1655 ASSERT_EQ(dragResizeType, appDragResizeType);
1656 }
1657
1658 /**
1659 * @tc.name: SetAppKeyFramePolicy01
1660 * @tc.desc: check SetAppKeyFramePolicy enable
1661 * @tc.type: FUNC
1662 */
1663 HWTEST_F(WindowManagerTest, SetAppKeyFramePolicy01, TestSize.Level1)
1664 {
1665 const std::string bundleName = "test";
1666 KeyFramePolicy keyFramePolicy;
1667 keyFramePolicy.dragResizeType_ = DragResizeType::RESIZE_KEY_FRAME;
1668 keyFramePolicy.animationDelay_ = 200;
1669 auto ret = WindowManager::GetInstance().SetAppKeyFramePolicy(bundleName, keyFramePolicy);
1670 ASSERT_EQ(WMError::WM_OK, ret);
1671 }
1672
1673 /**
1674 * @tc.name: SetAppKeyFramePolicy02
1675 * @tc.desc: check SetAppKeyFramePolicy disable
1676 * @tc.type: FUNC
1677 */
1678 HWTEST_F(WindowManagerTest, SetAppKeyFramePolicy02, TestSize.Level1)
1679 {
1680 const std::string bundleName = "test";
1681 KeyFramePolicy keyFramePolicy;
1682 keyFramePolicy.dragResizeType_ = DragResizeType::RESIZE_TYPE_UNDEFINED;
1683 auto ret = WindowManager::GetInstance().SetAppKeyFramePolicy(bundleName, keyFramePolicy);
1684 ASSERT_EQ(WMError::WM_OK, ret);
1685 }
1686
1687 /**
1688 * @tc.name: NotifyWMSConnected
1689 * @tc.desc: check NotifyWMSConnected
1690 * @tc.type: FUNC
1691 */
1692 HWTEST_F(WindowManagerTest, NotifyWMSConnected, TestSize.Level1)
1693 {
1694 WMError ret = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1695 ASSERT_NE(WMError::WM_OK, ret);
1696 WindowManager::GetInstance().pImpl_->NotifyWMSConnected(1, 2);
1697 }
1698
1699 /**
1700 * @tc.name: GetAllWindowLayoutInfo
1701 * @tc.desc: check GetAllWindowLayoutInfo
1702 * @tc.type: FUNC
1703 */
1704 HWTEST_F(WindowManagerTest, GetAllWindowLayoutInfo, TestSize.Level1)
1705 {
1706 DisplayId displayId = 1;
1707 std::vector<sptr<WindowLayoutInfo>> infos;
1708 auto ret = WindowManager::GetInstance().GetAllWindowLayoutInfo(displayId, infos);
1709 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().GetAllWindowLayoutInfo(displayId, infos), ret);
1710 }
1711
1712 /**
1713 * @tc.name: GetTopNavDestinationName
1714 * @tc.desc: test GetTopNavDestinationName rpc is ok
1715 * @tc.type: FUNC
1716 */
1717 HWTEST_F(WindowManagerTest, GetTopNavDestinationName, TestSize.Level1)
1718 {
1719 int32_t windowId = 888;
1720 std::string topNavDestName;
1721 auto ret = WindowManager::GetInstance().GetTopNavDestinationName(windowId, topNavDestName);
1722 EXPECT_EQ(SingletonContainer::Get<WindowAdapter>().GetTopNavDestinationName(windowId, topNavDestName), ret);
1723 }
1724
1725 /**
1726 * @tc.name: ShiftAppWindowPointerEvent
1727 * @tc.desc: check ShiftAppWindowPointerEvent
1728 * @tc.type: FUNC
1729 */
1730 HWTEST_F(WindowManagerTest, ShiftAppWindowPointerEvent, TestSize.Level1)
1731 {
1732 int32_t sourceWindowId = 1;
1733 int32_t targetWindowId = 1;
1734 int32_t fingerId = 0;
1735 auto ret = WindowManager::GetInstance().ShiftAppWindowPointerEvent(sourceWindowId, targetWindowId, fingerId);
1736 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().ShiftAppWindowPointerEvent(
1737 sourceWindowId, targetWindowId, fingerId), ret);
1738 }
1739
1740 /**
1741 * @tc.name: OnWMSConnectionChanged
1742 * @tc.desc: check OnWMSConnectionChanged
1743 * @tc.type: FUNC
1744 */
1745 HWTEST_F(WindowManagerTest, OnWMSConnectionChanged, TestSize.Level1)
1746 {
1747 int32_t userId = 1;
1748 int32_t screenId = 1;
1749 int32_t isConnected = 1;
1750
1751 WMError ret_1 = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1752 ASSERT_NE(WMError::WM_OK, ret_1);
1753 WindowManager::GetInstance().OnWMSConnectionChanged(userId, screenId, isConnected);
1754
1755 isConnected = 0;
1756 WMError ret_2 = WindowManager::GetInstance().ShiftAppWindowFocus(0, 1);
1757 ASSERT_NE(WMError::WM_OK, ret_2);
1758 WindowManager::GetInstance().OnWMSConnectionChanged(userId, screenId, isConnected);
1759 }
1760
1761 /**
1762 * @tc.name: RequestFocus
1763 * @tc.desc: check RequestFocus
1764 * @tc.type: FUNC
1765 */
1766 HWTEST_F(WindowManagerTest, RequestFocus, TestSize.Level1)
1767 {
1768 WindowManager windowManager;
1769 int32_t persistentId = 1;
1770 bool isFocused = true;
1771 bool byForeground = true;
1772 WindowFocusChangeReason reason = WindowFocusChangeReason::CLICK;
1773 auto result = windowManager.RequestFocus(
1774 persistentId, isFocused, byForeground, reason);
1775 ASSERT_NE(result, WMError::WM_OK);
1776 }
1777
1778 /**
1779 * @tc.name: MinimizeByWindowId
1780 * @tc.desc: Check MinimizeByWindowId
1781 * @tc.type: FUNC
1782 */
1783 HWTEST_F(WindowManagerTest, MinimizeByWindowId, TestSize.Level1)
1784 {
1785 auto& windowManager = WindowManager::GetInstance();
1786 std::vector<int32_t> windowIds;
1787 WMError ret_1 = windowManager.MinimizeByWindowId(windowIds);
1788 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret_1);
1789 windowIds = {-1, 0};
1790 WMError ret_2 = windowManager.MinimizeByWindowId(windowIds);
1791 ASSERT_EQ(WMError::WM_OK, ret_2);
1792 }
1793
1794 /**
1795 * @tc.name: ProcessRegisterWindowInfoChangeCallback01
1796 * @tc.desc: Check ProcessRegisterWindowInfoChangeCallback
1797 * @tc.type: FUNC
1798 */
1799 HWTEST_F(WindowManagerTest, ProcessRegisterWindowInfoChangeCallback01, Function | SmallTest | Level2)
1800 {
1801 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1802 WindowInfoKey observedInfo = WindowInfoKey::VISIBILITY_STATE;
1803 auto ret = WindowManager::GetInstance().ProcessRegisterWindowInfoChangeCallback(observedInfo, listener);
1804 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
1805 observedInfo = WindowInfoKey::DISPLAY_ID;
1806 ret = WindowManager::GetInstance().ProcessRegisterWindowInfoChangeCallback(observedInfo, listener);
1807 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
1808 observedInfo = WindowInfoKey::WINDOW_RECT;
1809 ret = WindowManager::GetInstance().ProcessRegisterWindowInfoChangeCallback(observedInfo, listener);
1810 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
1811 ret = WindowManager::GetInstance().ProcessRegisterWindowInfoChangeCallback(observedInfo, nullptr);
1812 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1813 observedInfo = WindowInfoKey::BUNDLE_NAME;
1814 ret = WindowManager::GetInstance().ProcessRegisterWindowInfoChangeCallback(observedInfo, listener);
1815 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1816 }
1817
1818 /**
1819 * @tc.name: ProcessUnregisterWindowInfoChangeCallback01
1820 * @tc.desc: Check ProcessUnregisterWindowInfoChangeCallback
1821 * @tc.type: FUNC
1822 */
1823 HWTEST_F(WindowManagerTest, ProcessUnregisterWindowInfoChangeCallback01, Function | SmallTest | Level2)
1824 {
1825 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1826 WindowInfoKey observedInfo = WindowInfoKey::VISIBILITY_STATE;
1827 auto ret = WindowManager::GetInstance().ProcessUnregisterWindowInfoChangeCallback(observedInfo, listener);
1828 EXPECT_EQ(WMError::WM_OK, ret);
1829 observedInfo = WindowInfoKey::DISPLAY_ID;
1830 ret = WindowManager::GetInstance().ProcessUnregisterWindowInfoChangeCallback(observedInfo, listener);
1831 EXPECT_EQ(WMError::WM_OK, ret);
1832 observedInfo = WindowInfoKey::WINDOW_RECT;
1833 ret = WindowManager::GetInstance().ProcessUnregisterWindowInfoChangeCallback(observedInfo, listener);
1834 EXPECT_EQ(WMError::WM_OK, ret);
1835 ret = WindowManager::GetInstance().ProcessUnregisterWindowInfoChangeCallback(observedInfo, nullptr);
1836 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1837 observedInfo = WindowInfoKey::BUNDLE_NAME;
1838 ret = WindowManager::GetInstance().ProcessUnregisterWindowInfoChangeCallback(observedInfo, listener);
1839 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1840 }
1841
1842 /**
1843 * @tc.name: RegisterWindowInfoChangeCallback01
1844 * @tc.desc: Check RegisterWindowInfoChangeCallback
1845 * @tc.type: FUNC
1846 */
1847 HWTEST_F(WindowManagerTest, RegisterWindowInfoChangeCallback01, Function | SmallTest | Level2)
1848 {
1849 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1850 auto interestInfoSizeOld = listener->GetInterestInfo().size();
1851 std::unordered_set<WindowInfoKey> observedInfo;
1852 observedInfo.insert(WindowInfoKey::VISIBILITY_STATE);
1853 auto ret = WindowManager::GetInstance().RegisterWindowInfoChangeCallback(observedInfo, listener);
1854 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
1855 EXPECT_EQ(interestInfoSizeOld + 1, listener->GetInterestInfo().size());
1856 std::unordered_set<WindowInfoKey> observedInfo1;
1857 observedInfo1.insert(WindowInfoKey::BUNDLE_NAME);
1858 ret = WindowManager::GetInstance().RegisterWindowInfoChangeCallback(observedInfo1, listener);
1859 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1860 ret = WindowManager::GetInstance().RegisterWindowInfoChangeCallback(observedInfo, nullptr);
1861 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1862 listener->SetInterestWindowIds({1, 2, 3});
1863 interestInfoSizeOld = listener->GetInterestInfo().size();
1864 ret = WindowManager::GetInstance().RegisterWindowInfoChangeCallback(observedInfo, listener);
1865 EXPECT_EQ(interestInfoSizeOld + 1, listener->GetInterestInfo().size());
1866 }
1867
1868 /**
1869 * @tc.name: UnregisterWindowInfoChangeCallback01
1870 * @tc.desc: Check UnregisterWindowInfoChangeCallback
1871 * @tc.type: FUNC
1872 */
1873 HWTEST_F(WindowManagerTest, UnregisterWindowInfoChangeCallback01, Function | SmallTest | Level2)
1874 {
1875 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1876 auto interestInfoSizeOld = listener->GetInterestInfo().size();
1877 std::unordered_set<WindowInfoKey> observedInfo;
1878 observedInfo.insert(WindowInfoKey::VISIBILITY_STATE);
1879 auto ret = WindowManager::GetInstance().UnregisterWindowInfoChangeCallback(observedInfo, listener);
1880 EXPECT_EQ(WMError::WM_OK, ret);
1881 EXPECT_EQ(interestInfoSizeOld + 1, listener->GetInterestInfo().size());
1882 std::unordered_set<WindowInfoKey> observedInfo1;
1883 observedInfo1.insert(WindowInfoKey::BUNDLE_NAME);
1884 ret = WindowManager::GetInstance().UnregisterWindowInfoChangeCallback(observedInfo1, listener);
1885 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1886 ret = WindowManager::GetInstance().UnregisterWindowInfoChangeCallback(observedInfo, nullptr);
1887 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1888 listener->SetInterestWindowIds({1, 2, 3});
1889 interestInfoSizeOld = listener->GetInterestInfo().size();
1890 ret = WindowManager::GetInstance().UnregisterWindowInfoChangeCallback(observedInfo, listener);
1891 EXPECT_EQ(interestInfoSizeOld + 1, listener->GetInterestInfo().size());
1892 }
1893
1894 /**
1895 * @tc.name: RegisterVisibilityStateChangedListener01
1896 * @tc.desc: check RegisterVisibilityStateChangedListener
1897 * @tc.type: FUNC
1898 */
1899 HWTEST_F(WindowManagerTest, RegisterVisibilityStateChangedListener01, Function | SmallTest | Level2)
1900 {
1901 auto& windowManager = WindowManager::GetInstance();
1902 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityStateListenerAgent_;
1903 auto oldListeners = windowManager.pImpl_->windowVisibilityStateListeners_;
1904 windowManager.pImpl_->windowVisibilityStateListenerAgent_ = nullptr;
1905 windowManager.pImpl_->windowVisibilityStateListeners_.clear();
1906 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(nullptr));
1907
1908 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1909 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1910 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1911 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(listener));
1912 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityStateListenerAgent_);
1913
1914 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1915 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
1916 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1917
1918 // to check that the same listner can not be registered twice
1919 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1920 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
1921 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1922
1923 windowManager.pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
1924 windowManager.pImpl_->windowVisibilityStateListeners_ = oldListeners;
1925 }
1926
1927 /**
1928 * @tc.name: UnregisterVisibilityStateChangedListener01
1929 * @tc.desc: check UnregisterVisibilityStateChangedListener
1930 * @tc.type: FUNC
1931 */
1932 HWTEST_F(WindowManagerTest, UnregisterVisibilityStateChangedListener01, Function | SmallTest | Level2)
1933 {
1934 auto& windowManager = WindowManager::GetInstance();
1935 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityStateListenerAgent_;
1936 auto oldListeners = windowManager.pImpl_->windowVisibilityStateListeners_;
1937 windowManager.pImpl_->windowVisibilityStateListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
1938 windowManager.pImpl_->windowVisibilityStateListeners_.clear();
1939
1940 // check nullpter
1941 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityStateChangedListener(nullptr));
1942
1943 sptr<TestWindowVisibilityStateListener> listener1 = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1944 sptr<TestWindowVisibilityStateListener> listener2 = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1945 ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.UnregisterVisibilityStateChangedListener(listener1));
1946
1947 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1948 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1949 windowManager.RegisterVisibilityStateChangedListener(listener1);
1950 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1951 windowManager.RegisterVisibilityStateChangedListener(listener2);
1952 ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1953
1954 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener1));
1955 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1956 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener2));
1957 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1958 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityStateListenerAgent_);
1959
1960 windowManager.pImpl_->windowVisibilityStateListeners_.emplace_back(listener1);
1961 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener1));
1962 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1963
1964 windowManager.pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
1965 windowManager.pImpl_->windowVisibilityStateListeners_ = oldListeners;
1966 }
1967
1968 /**
1969 * @tc.name: RegisterDisplayIdChangedListener01
1970 * @tc.desc: check RegisterDisplayIdChangedListener
1971 * @tc.type: FUNC
1972 */
1973 HWTEST_F(WindowManagerTest, RegisterDisplayIdChangedListener01, Function | SmallTest | Level2)
1974 {
1975 auto& windowManager = WindowManager::GetInstance();
1976 auto oldWindowManagerAgent = windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_;
1977 auto oldListeners = windowManager.pImpl_->windowDisplayIdChangeListeners_;
1978 windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_ = nullptr;
1979 windowManager.pImpl_->windowDisplayIdChangeListeners_.clear();
1980 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(nullptr));
1981
1982 sptr<TestWindowDisplayIdChangeListener> listener = sptr<TestWindowDisplayIdChangeListener>::MakeSptr();
1983 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1984 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1985 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(listener));
1986 ASSERT_EQ(nullptr, windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_);
1987
1988 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1989 EXPECT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
1990 EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
1991
1992 // to check that the same listner can not be registered twice
1993 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1994 EXPECT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
1995 EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
1996
1997 windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_ = oldWindowManagerAgent;
1998 windowManager.pImpl_->windowDisplayIdChangeListeners_ = oldListeners;
1999 }
2000
2001 /**
2002 * @tc.name: UnregisterDisplayIdChangedListener01
2003 * @tc.desc: check UnregisterDisplayIdChangedListener
2004 * @tc.type: FUNC
2005 */
2006 HWTEST_F(WindowManagerTest, UnregisterDisplayIdChangedListener01, Function | SmallTest | Level2)
2007 {
2008 auto& windowManager = WindowManager::GetInstance();
2009 auto oldWindowManagerAgent = windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_;
2010 auto oldListeners = windowManager.pImpl_->windowDisplayIdChangeListeners_;
2011 windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
2012 windowManager.pImpl_->windowDisplayIdChangeListeners_.clear();
2013
2014 // check nullpter
2015 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayIdChangedListener(nullptr));
2016
2017 sptr<TestWindowDisplayIdChangeListener> listener1 = sptr<TestWindowDisplayIdChangeListener>::MakeSptr();
2018 sptr<TestWindowDisplayIdChangeListener> listener2 = sptr<TestWindowDisplayIdChangeListener>::MakeSptr();
2019 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.UnregisterDisplayIdChangedListener(listener1));
2020
2021 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
2022 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2023 windowManager.RegisterVisibilityStateChangedListener(listener1);
2024 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2025 windowManager.RegisterVisibilityStateChangedListener(listener2);
2026 EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
2027
2028 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayIdChangedListener(listener1));
2029 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayIdChangedListener(listener2));
2030 EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
2031 ASSERT_EQ(nullptr, windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_);
2032
2033 windowManager.pImpl_->windowDisplayIdChangeListeners_.emplace_back(listener1);
2034 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayIdChangedListener(listener1));
2035 EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
2036
2037 windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_ = oldWindowManagerAgent;
2038 windowManager.pImpl_->windowDisplayIdChangeListeners_ = oldListeners;
2039 }
2040
2041 /**
2042 * @tc.name: RegisterWindowSystemBarPropertyChangedListener
2043 * @tc.desc: check RegisterWindowSystemBarPropertyChangedListener
2044 * @tc.type: FUNC
2045 */
2046 HWTEST_F(WindowManagerTest, RegisterWindowSystemBarPropertyChangedListener, Function | SmallTest | Level2)
2047 {
2048 auto& windowManager = WindowManager::GetInstance();
2049 auto oldWindowManagerAgent = windowManager.pImpl_->windowSystemBarPropertyChangeAgent_;
2050 auto oldListeners = windowManager.pImpl_->windowSystemBarPropertyChangedListeners_;
2051 windowManager.pImpl_->windowSystemBarPropertyChangeAgent_ = nullptr;
2052 windowManager.pImpl_->windowSystemBarPropertyChangedListeners_.clear();
2053 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowSystemBarPropertyChangedListener(nullptr));
2054 sptr<TestWindowSystemBarPropertyChangedListener> listener =
2055 sptr<TestWindowSystemBarPropertyChangedListener>::MakeSptr();
2056 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
2057 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2058 EXPECT_EQ(WMError::WM_OK, windowManager.RegisterWindowSystemBarPropertyChangedListener(listener));
2059 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2060 EXPECT_EQ(WMError::WM_DO_NOTHING, windowManager.RegisterWindowSystemBarPropertyChangedListener(listener));
2061 windowManager.pImpl_->windowSystemBarPropertyChangeAgent_ = oldWindowManagerAgent;
2062 windowManager.pImpl_->windowSystemBarPropertyChangedListeners_ = oldListeners;
2063 }
2064
2065 /**
2066 * @tc.name: UnregisterWindowSystemBarPropertyChangedListener
2067 * @tc.desc: check UnregisterWindowSystemBarPropertyChangedListener
2068 * @tc.type: FUNC
2069 */
2070 HWTEST_F(WindowManagerTest, UnregisterWindowSystemBarPropertyChangedListener, Function | SmallTest | Level2)
2071 {
2072 auto& windowManager = WindowManager::GetInstance();
2073 auto oldWindowManagerAgent = windowManager.pImpl_->windowSystemBarPropertyChangeAgent_;
2074 auto oldListeners = windowManager.pImpl_->windowSystemBarPropertyChangedListeners_;
2075 windowManager.pImpl_->windowSystemBarPropertyChangeAgent_ = sptr<WindowManagerAgent>::MakeSptr();
2076 windowManager.pImpl_->windowSystemBarPropertyChangedListeners_.clear();
2077 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowSystemBarPropertyChangedListener(nullptr));
2078 sptr<TestWindowSystemBarPropertyChangedListener> listener =
2079 sptr<TestWindowSystemBarPropertyChangedListener>::MakeSptr();
2080 EXPECT_EQ(WMError::WM_DO_NOTHING, windowManager.UnregisterWindowSystemBarPropertyChangedListener(listener));
2081 windowManager.pImpl_->windowSystemBarPropertyChangedListeners_.emplace_back(listener);
2082 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterWindowSystemBarPropertyChangedListener(listener));
2083 windowManager.pImpl_->windowSystemBarPropertyChangeAgent_ = oldWindowManagerAgent;
2084 windowManager.pImpl_->windowSystemBarPropertyChangedListeners_ = oldListeners;
2085 }
2086
2087 /**
2088 * @tc.name: NotifyWindowSystemBarPropertyChange
2089 * @tc.desc: check NotifyWindowSystemBarPropertyChange
2090 * @tc.type: FUNC
2091 */
2092 HWTEST_F(WindowManagerTest, NotifyWindowSystemBarPropertyChange, TestSize.Level1)
2093 {
2094 auto& windowManager = WindowManager::GetInstance();
2095 auto oldListeners = windowManager.pImpl_->windowSystemBarPropertyChangedListeners_;
2096 SystemBarProperty systemBarProperty;
2097 WindowManager::GetInstance().pImpl_->NotifyWindowSystemBarPropertyChange(
2098 WindowType::WINDOW_TYPE_STATUS_BAR, systemBarProperty);
2099 sptr<TestWindowSystemBarPropertyChangedListener> listener =
2100 sptr<TestWindowSystemBarPropertyChangedListener>::MakeSptr();
2101 windowManager.pImpl_->windowSystemBarPropertyChangedListeners_.emplace_back(listener);
2102 EXPECT_EQ(1, windowManager.pImpl_->windowSystemBarPropertyChangedListeners_.size());
2103 WindowManager::GetInstance().pImpl_->NotifyWindowSystemBarPropertyChange(
2104 WindowType::WINDOW_TYPE_STATUS_BAR, systemBarProperty);
2105 EXPECT_EQ(1, listener->count_);
2106 windowManager.pImpl_->windowSystemBarPropertyChangedListeners_ = oldListeners;
2107 }
2108
2109 /**
2110 * @tc.name: RegisterFloatingScaleChangedListener01
2111 * @tc.desc: check RegisterFloatingScaleChangedListener
2112 * @tc.type: FUNC
2113 */
2114 HWTEST_F(WindowManagerTest, RegisterFloatingScaleChangedListener01, Function | SmallTest | Level2)
2115 {
2116 auto& windowManager = WindowManager::GetInstance();
2117 auto oldWindowManagerAgent = windowManager.pImpl_->windowPropertyChangeAgent_;
2118 auto oldListeners = windowManager.pImpl_->floatingScaleChangeListeners_;
2119 windowManager.pImpl_->windowPropertyChangeAgent_ = nullptr;
2120 windowManager.pImpl_->floatingScaleChangeListeners_.clear();
2121 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterFloatingScaleChangedListener(nullptr));
2122
2123 sptr<TestFloatingScaleChangedListener> listener = sptr<TestFloatingScaleChangedListener>::MakeSptr();
2124
2125 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.RegisterFloatingScaleChangedListener(listener));
2126 EXPECT_EQ(0, windowManager.pImpl_->floatingScaleChangeListeners_.size());
2127
2128 // to check that the same listner can not be registered twice
2129 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.RegisterFloatingScaleChangedListener(listener));
2130 EXPECT_EQ(0, windowManager.pImpl_->floatingScaleChangeListeners_.size());
2131
2132 windowManager.pImpl_->windowPropertyChangeAgent_ = oldWindowManagerAgent;
2133 windowManager.pImpl_->floatingScaleChangeListeners_ = oldListeners;
2134 }
2135
2136 /**
2137 * @tc.name: UnregisterFloatingScaleChangedListener01
2138 * @tc.desc: check UnregisterFloatingScaleChangedListener
2139 * @tc.type: FUNC
2140 */
2141 HWTEST_F(WindowManagerTest, UnregisterFloatingScaleChangedListener01, Function | SmallTest | Level2)
2142 {
2143 auto& windowManager = WindowManager::GetInstance();
2144 auto oldWindowManagerAgent = windowManager.pImpl_->windowPropertyChangeAgent_;
2145 auto oldListeners = windowManager.pImpl_->floatingScaleChangeListeners_;
2146 windowManager.pImpl_->windowPropertyChangeAgent_ = sptr<WindowManagerAgent>::MakeSptr();
2147 windowManager.pImpl_->floatingScaleChangeListeners_.clear();
2148
2149 // check nullpter
2150 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterFloatingScaleChangedListener(nullptr));
2151
2152 sptr<TestFloatingScaleChangedListener> listener1 = sptr<TestFloatingScaleChangedListener>::MakeSptr();
2153 sptr<TestFloatingScaleChangedListener> listener2 = sptr<TestFloatingScaleChangedListener>::MakeSptr();
2154 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.UnregisterFloatingScaleChangedListener(listener1));
2155
2156 windowManager.RegisterFloatingScaleChangedListener(listener1);
2157 windowManager.RegisterFloatingScaleChangedListener(listener2);
2158 EXPECT_EQ(0, windowManager.pImpl_->floatingScaleChangeListeners_.size());
2159
2160 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterFloatingScaleChangedListener(listener1));
2161 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterFloatingScaleChangedListener(listener2));
2162 EXPECT_EQ(0, windowManager.pImpl_->floatingScaleChangeListeners_.size());
2163 ASSERT_EQ(nullptr, windowManager.pImpl_->windowPropertyChangeAgent_);
2164
2165 windowManager.pImpl_->floatingScaleChangeListeners_.emplace_back(listener1);
2166 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterFloatingScaleChangedListener(listener1));
2167 EXPECT_EQ(0, windowManager.pImpl_->floatingScaleChangeListeners_.size());
2168
2169 windowManager.pImpl_->windowPropertyChangeAgent_ = oldWindowManagerAgent;
2170 windowManager.pImpl_->floatingScaleChangeListeners_ = oldListeners;
2171 }
2172
2173 /**
2174 * @tc.name: NotifyFloatingScaleChange
2175 * @tc.desc: check NotifyFloatingScaleChange
2176 * @tc.type: FUNC
2177 */
2178 HWTEST_F(WindowManagerTest, NotifyFloatingScaleChange, TestSize.Level1)
2179 {
2180 std::vector<std::unordered_map<WindowInfoKey, WindowChangeInfoType>> windowInfoList;
2181 windowInfoList.push_back({{WindowInfoKey::DISPLAY_ID, 5}});
2182
2183 auto& windowManager = WindowManager::GetInstance();
2184 windowManager.pImpl_->floatingScaleChangeListeners_.clear();
2185 windowManager.pImpl_->NotifyFloatingScaleChange(windowInfoList);
2186
2187 windowManager.pImpl_->floatingScaleChangeListeners_.push_back(nullptr);
2188 windowManager.pImpl_->NotifyFloatingScaleChange(windowInfoList);
2189
2190 sptr<TestFloatingScaleChangedListener> listener =
2191 sptr<TestFloatingScaleChangedListener>::MakeSptr();
2192
2193 windowManager.pImpl_->NotifyFloatingScaleChange(windowInfoList);
2194 EXPECT_EQ(listener->count_, 0);
2195 }
2196
2197 /**
2198 * @tc.name: RegisterWindowModeChangedListenerForPropertyChange01
2199 * @tc.desc: check RegisterWindowModeChangedListenerForPropertyChange
2200 * @tc.type: FUNC
2201 */
2202 HWTEST_F(WindowManagerTest, RegisterWindowModeChangedListenerForPropertyChange01, Function | SmallTest | Level2)
2203 {
2204 auto& windowManager = WindowManager::GetInstance();
2205 auto oldWindowManagerAgent = windowManager.pImpl_->windowPropertyChangeAgent_;
2206 auto oldListeners = windowManager.pImpl_->windowModeChangeListeners_;
2207 windowManager.pImpl_->windowPropertyChangeAgent_ = nullptr;
2208 windowManager.pImpl_->windowModeChangeListeners_.clear();
2209 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListenerForPropertyChange(nullptr));
2210
2211 sptr<TestWindowModeChangedListenerForPropertyChange> listener =
2212 sptr<TestWindowModeChangedListenerForPropertyChange>::MakeSptr();
2213
2214 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION,
2215 windowManager.RegisterWindowModeChangedListenerForPropertyChange(listener));
2216 EXPECT_EQ(0, windowManager.pImpl_->windowModeChangeListeners_.size());
2217
2218 // to check that the same listner can not be registered twice
2219 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION,
2220 windowManager.RegisterWindowModeChangedListenerForPropertyChange(listener));
2221 EXPECT_EQ(0, windowManager.pImpl_->windowModeChangeListeners_.size());
2222
2223 windowManager.pImpl_->windowPropertyChangeAgent_ = oldWindowManagerAgent;
2224 windowManager.pImpl_->windowModeChangeListeners_ = oldListeners;
2225 }
2226
2227 /**
2228 * @tc.name: UnregisterWindowModeChangedListenerForPropertyChange01
2229 * @tc.desc: check UnregisterWindowModeChangedListenerForPropertyChange
2230 * @tc.type: FUNC
2231 */
2232 HWTEST_F(WindowManagerTest, UnregisterWindowModeChangedListenerForPropertyChange01, Function | SmallTest | Level2)
2233 {
2234 auto& windowManager = WindowManager::GetInstance();
2235 auto oldWindowManagerAgent = windowManager.pImpl_->windowPropertyChangeAgent_;
2236 auto oldListeners = windowManager.pImpl_->windowModeChangeListeners_;
2237 windowManager.pImpl_->windowPropertyChangeAgent_ = sptr<WindowManagerAgent>::MakeSptr();
2238 windowManager.pImpl_->windowModeChangeListeners_.clear();
2239
2240 // check nullpter
2241 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowModeChangedListenerForPropertyChange(nullptr));
2242
2243 sptr<TestWindowModeChangedListenerForPropertyChange> listener1 =
2244 sptr<TestWindowModeChangedListenerForPropertyChange>::MakeSptr();
2245 sptr<TestWindowModeChangedListenerForPropertyChange> listener2 =
2246 sptr<TestWindowModeChangedListenerForPropertyChange>::MakeSptr();
2247 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION,
2248 windowManager.UnregisterWindowModeChangedListenerForPropertyChange(listener1));
2249
2250 windowManager.RegisterWindowModeChangedListenerForPropertyChange(listener1);
2251 windowManager.RegisterWindowModeChangedListenerForPropertyChange(listener2);
2252 EXPECT_EQ(0, windowManager.pImpl_->windowModeChangeListeners_.size());
2253
2254 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListenerForPropertyChange(listener1));
2255 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListenerForPropertyChange(listener2));
2256 EXPECT_EQ(0, windowManager.pImpl_->windowModeChangeListeners_.size());
2257 ASSERT_EQ(nullptr, windowManager.pImpl_->windowPropertyChangeAgent_);
2258
2259 windowManager.pImpl_->windowModeChangeListeners_.emplace_back(listener1);
2260 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListenerForPropertyChange(listener1));
2261 EXPECT_EQ(0, windowManager.pImpl_->windowModeChangeListeners_.size());
2262
2263 windowManager.pImpl_->windowPropertyChangeAgent_ = oldWindowManagerAgent;
2264 windowManager.pImpl_->windowModeChangeListeners_ = oldListeners;
2265 }
2266
2267 /**
2268 * @tc.name: NotifyWindowModeChangeForPropertyChange
2269 * @tc.desc: check NotifyWindowModeChangeForPropertyChange
2270 * @tc.type: FUNC
2271 */
2272 HWTEST_F(WindowManagerTest, NotifyWindowModeChangeForPropertyChange, TestSize.Level1)
2273 {
2274 std::vector<std::unordered_map<WindowInfoKey, WindowChangeInfoType>> windowInfoList;
2275 windowInfoList.push_back({{WindowInfoKey::DISPLAY_ID, 5}});
2276
2277 auto& windowManager = WindowManager::GetInstance();
2278 windowManager.pImpl_->windowModeChangeListeners_.clear();
2279 windowManager.pImpl_->NotifyWindowModeChangeForPropertyChange(windowInfoList);
2280
2281 windowManager.pImpl_->windowModeChangeListeners_.push_back(nullptr);
2282 windowManager.pImpl_->NotifyWindowModeChangeForPropertyChange(windowInfoList);
2283
2284 sptr<TestWindowModeChangedListenerForPropertyChange> listener =
2285 sptr<TestWindowModeChangedListenerForPropertyChange>::MakeSptr();
2286
2287 windowManager.pImpl_->NotifyWindowModeChangeForPropertyChange(windowInfoList);
2288 EXPECT_EQ(listener->count_, 0);
2289 }
2290
2291 /**
2292 * @tc.name: RegisterRectChangedListener01
2293 * @tc.desc: check RegisterRectChangedListener
2294 * @tc.type: FUNC
2295 */
2296 HWTEST_F(WindowManagerTest, RegisterRectChangedListener01, Function | SmallTest | Level2)
2297 {
2298 auto& windowManager = WindowManager::GetInstance();
2299 auto oldWindowManagerAgent = windowManager.pImpl_->windowPropertyChangeAgent_;
2300 auto oldListeners = windowManager.pImpl_->windowRectChangeListeners_;
2301 windowManager.pImpl_->windowPropertyChangeAgent_ = nullptr;
2302 windowManager.pImpl_->windowRectChangeListeners_.clear();
2303 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterRectChangedListener(nullptr));
2304
2305 sptr<TestWindowRectChangedListener> listener = sptr<TestWindowRectChangedListener>::MakeSptr();
2306 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
2307
2308 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2309 EXPECT_EQ(WMError::WM_OK, windowManager.RegisterRectChangedListener(listener));
2310 EXPECT_EQ(0, windowManager.pImpl_->windowRectChangeListeners_.size());
2311
2312 // to check that the same listner can not be registered twice
2313 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2314 EXPECT_EQ(WMError::WM_OK, windowManager.RegisterRectChangedListener(listener));
2315 EXPECT_EQ(0, windowManager.pImpl_->windowRectChangeListeners_.size());
2316
2317 windowManager.pImpl_->windowPropertyChangeAgent_ = oldWindowManagerAgent;
2318 windowManager.pImpl_->windowRectChangeListeners_ = oldListeners;
2319 }
2320
2321 /**
2322 * @tc.name: UnregisterRectChangedListener01
2323 * @tc.desc: check UnregisterRectChangedListener
2324 * @tc.type: FUNC
2325 */
2326 HWTEST_F(WindowManagerTest, UnregisterRectChangedListener01, Function | SmallTest | Level2)
2327 {
2328 auto& windowManager = WindowManager::GetInstance();
2329 auto oldWindowManagerAgent = windowManager.pImpl_->windowPropertyChangeAgent_;
2330 auto oldListeners = windowManager.pImpl_->windowRectChangeListeners_;
2331 windowManager.pImpl_->windowPropertyChangeAgent_ = sptr<WindowManagerAgent>::MakeSptr();
2332 windowManager.pImpl_->windowRectChangeListeners_.clear();
2333
2334 // check nullpter
2335 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterRectChangedListener(nullptr));
2336
2337 sptr<TestWindowRectChangedListener> listener1 = sptr<TestWindowRectChangedListener>::MakeSptr();
2338 sptr<TestWindowRectChangedListener> listener2 = sptr<TestWindowRectChangedListener>::MakeSptr();
2339 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterRectChangedListener(listener1));
2340
2341 windowManager.RegisterRectChangedListener(listener1);
2342 windowManager.RegisterRectChangedListener(listener2);
2343 EXPECT_EQ(0, windowManager.pImpl_->windowRectChangeListeners_.size());
2344
2345 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterRectChangedListener(listener1));
2346 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterRectChangedListener(listener2));
2347 EXPECT_EQ(0, windowManager.pImpl_->windowRectChangeListeners_.size());
2348
2349 windowManager.pImpl_->windowRectChangeListeners_.emplace_back(listener1);
2350 EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterRectChangedListener(listener1));
2351 EXPECT_EQ(0, windowManager.pImpl_->windowRectChangeListeners_.size());
2352
2353 windowManager.pImpl_->windowPropertyChangeAgent_ = oldWindowManagerAgent;
2354 windowManager.pImpl_->windowRectChangeListeners_ = oldListeners;
2355 }
2356
2357 /**
2358 * @tc.name: AnimateTo01
2359 * @tc.desc: check AnimateTo
2360 * @tc.type: FUNC
2361 */
2362 HWTEST_F(WindowManagerTest, AnimateTo01, Function | SmallTest | Level2)
2363 {
2364 int32_t windowId = 1;
2365 WindowAnimationProperty animationProperty;
2366 WindowAnimationOption animationOption;
2367 animationProperty.targetScale = 1.5f;
2368
2369 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
2370 EXPECT_CALL(m->Mock(), AnimateTo(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2371 WMError ret = WindowManager::GetInstance().AnimateTo(windowId, animationProperty, animationOption);
2372 EXPECT_EQ(ret, WMError::WM_OK);
2373
2374 EXPECT_CALL(m->Mock(), AnimateTo(_, _, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
2375 ret = WindowManager::GetInstance().AnimateTo(windowId, animationProperty, animationOption);
2376 EXPECT_EQ(ret, WMError::WM_DO_NOTHING);
2377 }
2378
2379 /**
2380 * @tc.name: RegisterWindowLifeCycleListener01
2381 * @tc.desc: check RegisterWindowLifeCycleCallback
2382 * @tc.type: FUNC
2383 */
2384 HWTEST_F(WindowManagerTest, RegisterWindowLifeCycleListener01, TestSize.Level1)
2385 {
2386 WMError ret;
2387 sptr<TestIWindowLifeCycleListener> listener = sptr<TestIWindowLifeCycleListener>::MakeSptr();
2388 ret = WindowManager::GetInstance().RegisterWindowLifeCycleCallback(listener);
2389 EXPECT_EQ(WMError::WM_OK, ret);
2390
2391 ret = WindowManager::GetInstance().RegisterWindowLifeCycleCallback(nullptr);
2392 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
2393
2394 ret = WindowManager::GetInstance().RegisterWindowLifeCycleCallback(listener);
2395 EXPECT_EQ(WMError::WM_OK, ret);
2396 }
2397
2398 /**
2399 * @tc.name: UnregisterWindowLifeCycleListener01
2400 * @tc.desc: check UnregisterWindowLifeCycleCallback
2401 * @tc.type: FUNC
2402 */
2403 HWTEST_F(WindowManagerTest, UnregisterWindowLifeCycleListener01, TestSize.Level1)
2404 {
2405 WMError ret;
2406 sptr<TestIWindowLifeCycleListener> listener = sptr<TestIWindowLifeCycleListener>::MakeSptr();
2407 ret = WindowManager::GetInstance().UnregisterWindowLifeCycleCallback(listener);
2408 EXPECT_EQ(WMError::WM_OK, ret);
2409
2410 ret = WindowManager::GetInstance().UnregisterWindowLifeCycleCallback(nullptr);
2411 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
2412
2413 ret = WindowManager::GetInstance().UnregisterWindowLifeCycleCallback(listener);
2414 EXPECT_EQ(WMError::WM_OK, ret);
2415 }
2416
2417 /**
2418 * @tc.name: NotifyWMSWindowDestroyed01
2419 * @tc.desc: check NotifyWMSWindowDestroyed
2420 * @tc.type: FUNC
2421 */
2422 HWTEST_F(WindowManagerTest, NotifyWMSWindowDestroyed01, TestSize.Level1)
2423 {
2424 WMError ret;
2425 sptr<TestIWindowLifeCycleListener> listener = sptr<TestIWindowLifeCycleListener>::MakeSptr();
2426 ret = WindowManager::GetInstance().RegisterWindowLifeCycleCallback(listener);
2427 EXPECT_EQ(WMError::WM_OK, ret);
2428
2429 WindowLifeCycleInfo lifeCycleInfo;
2430 lifeCycleInfo.windowId = 101;
2431 lifeCycleInfo.windowType = WindowType::APP_WINDOW_BASE;
2432 lifeCycleInfo.windowName = "window101";
2433 WindowManager::GetInstance().NotifyWMSWindowDestroyed(lifeCycleInfo);
2434 EXPECT_EQ(lifeCycleInfo.windowId, listener->listenerLifeCycleInfo.windowId);
2435 EXPECT_EQ(lifeCycleInfo.windowType, listener->listenerLifeCycleInfo.windowType);
2436 EXPECT_EQ(lifeCycleInfo.windowName, listener->listenerLifeCycleInfo.windowName);
2437
2438 lifeCycleInfo.windowId = 102;
2439 lifeCycleInfo.windowType = WindowType::APP_SUB_WINDOW_BASE;
2440 lifeCycleInfo.windowName = "window102";
2441 WindowManager::GetInstance().NotifyWMSWindowDestroyed(lifeCycleInfo);
2442 EXPECT_EQ(lifeCycleInfo.windowId, listener->listenerLifeCycleInfo.windowId);
2443 EXPECT_EQ(lifeCycleInfo.windowType, listener->listenerLifeCycleInfo.windowType);
2444 EXPECT_EQ(lifeCycleInfo.windowName, listener->listenerLifeCycleInfo.windowName);
2445
2446 lifeCycleInfo.windowId = 103;
2447 lifeCycleInfo.windowType = WindowType::SYSTEM_WINDOW_BASE;
2448 lifeCycleInfo.windowName = "window103";
2449 WindowManager::GetInstance().NotifyWMSWindowDestroyed(lifeCycleInfo);
2450 EXPECT_EQ(lifeCycleInfo.windowId, listener->listenerLifeCycleInfo.windowId);
2451 EXPECT_EQ(lifeCycleInfo.windowType, listener->listenerLifeCycleInfo.windowType);
2452 EXPECT_EQ(lifeCycleInfo.windowName, listener->listenerLifeCycleInfo.windowName);
2453
2454 lifeCycleInfo.windowId = 104;
2455 lifeCycleInfo.windowType = WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE;
2456 lifeCycleInfo.windowName = "window104";
2457 WindowManager::GetInstance().NotifyWMSWindowDestroyed(lifeCycleInfo);
2458 EXPECT_EQ(lifeCycleInfo.windowId, listener->listenerLifeCycleInfo.windowId);
2459 EXPECT_EQ(lifeCycleInfo.windowType, listener->listenerLifeCycleInfo.windowType);
2460 EXPECT_EQ(lifeCycleInfo.windowName, listener->listenerLifeCycleInfo.windowName);
2461
2462 lifeCycleInfo.windowId = 105;
2463 lifeCycleInfo.windowType = WindowType::SYSTEM_SUB_WINDOW_BASE;
2464 lifeCycleInfo.windowName = "window105";
2465 WindowManager::GetInstance().NotifyWMSWindowDestroyed(lifeCycleInfo);
2466 EXPECT_EQ(lifeCycleInfo.windowId, listener->listenerLifeCycleInfo.windowId);
2467 EXPECT_EQ(lifeCycleInfo.windowType, listener->listenerLifeCycleInfo.windowType);
2468 EXPECT_EQ(lifeCycleInfo.windowName, listener->listenerLifeCycleInfo.windowName);
2469 }
2470
2471 /**
2472 * @tc.name: NotifyWMSWindowDestroyed02
2473 * @tc.desc: check NotifyWMSWindowDestroyed
2474 * @tc.type: FUNC
2475 */
2476 HWTEST_F(WindowManagerTest, NotifyWMSWindowDestroyed02, TestSize.Level1)
2477 {
2478 WMError ret;
2479 sptr<TestIWindowLifeCycleListener> listener = sptr<TestIWindowLifeCycleListener>::MakeSptr();
2480 ret = WindowManager::GetInstance().UnregisterWindowLifeCycleCallback(listener);
2481 EXPECT_EQ(WMError::WM_OK, ret);
2482
2483 WindowLifeCycleInfo lifeCycleInfo;
2484 lifeCycleInfo.windowId = 101;
2485 lifeCycleInfo.windowType = WindowType::APP_WINDOW_BASE;
2486 lifeCycleInfo.windowName = "window101";
__anonf9b9feec0302(const std::string& windowName) 2487 auto func = [](const std::string& windowName) {
2488 std::cout << "window name: " << windowName << std::endl;
2489 return napi_value();
2490 };
2491 WindowManager::GetInstance().RegisterGetJSWindowCallback(func);
2492 WindowManager::GetInstance().NotifyWMSWindowDestroyed(lifeCycleInfo);
2493 EXPECT_NE(lifeCycleInfo.windowId, listener->listenerLifeCycleInfo.windowId);
2494 EXPECT_NE(lifeCycleInfo.windowType, listener->listenerLifeCycleInfo.windowType);
2495 EXPECT_NE(lifeCycleInfo.windowName, listener->listenerLifeCycleInfo.windowName);
2496 }
2497
2498 /**
2499 * @tc.name: AddSessionBlackList01
2500 * @tc.desc: check AddSessionBlackList
2501 * @tc.type: FUNC
2502 */
2503 HWTEST_F(WindowManagerTest, AddSessionBlackList01, TestSize.Level1)
2504 {
2505 WMError ret;
2506 std::unordered_set<std::string> bundleNames;
2507 std::unordered_set<std::string> privacyWindowTags;
2508 ret = WindowManager::GetInstance().AddSessionBlackList(bundleNames, privacyWindowTags);
2509 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
2510 }
2511
2512 /**
2513 * @tc.name: RemoveSessionBlackList01
2514 * @tc.desc: check RemoveSessionBlackList
2515 * @tc.type: FUNC
2516 */
2517 HWTEST_F(WindowManagerTest, RemoveSessionBlackList01, TestSize.Level1)
2518 {
2519 WMError ret;
2520 std::unordered_set<std::string> bundleNames;
2521 std::unordered_set<std::string> privacyWindowTags;
2522 ret = WindowManager::GetInstance().RemoveSessionBlackList(bundleNames, privacyWindowTags);
2523 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
2524 }
2525 }
2526 } // namespace
2527 } // namespace Rosen
2528 } // namespace OHOS