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 "window_manager.h"
18 #include "mock_window_adapter.h"
19 #include "singleton_mocker.h"
20
21 #include "window_manager.cpp"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
29 class TestCameraFloatWindowChangedListener : public ICameraFloatWindowChangedListener {
30 public:
OnCameraFloatWindowChange(uint32_t accessTokenId,bool isShowing)31 void OnCameraFloatWindowChange(uint32_t accessTokenId, bool isShowing) override
32 {
33 WLOGI("TestCameraFloatWindowChangedListener [%{public}u, %{public}u]", accessTokenId, isShowing);
34 };
35 };
36
37 class TestVisibilityChangedListener : public IVisibilityChangedListener {
38 public:
OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>> & windowVisibilityInfo)39 void OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfo) override
40 {
41 WLOGI("TestVisibilityChangedListener");
42 };
43 };
44
45 class TestSystemBarChangedListener : public ISystemBarChangedListener {
46 public:
OnSystemBarPropertyChange(DisplayId displayId,const SystemBarRegionTints & tints)47 void OnSystemBarPropertyChange(DisplayId displayId, const SystemBarRegionTints& tints) override
48 {
49 WLOGI("TestSystemBarChangedListener");
50 };
51 };
52
53 class TestWindowUpdateListener : public IWindowUpdateListener {
54 public:
OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>> & infos,WindowUpdateType type)55 void OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>>& infos, WindowUpdateType type) override
56 {
57 WLOGI("TestWindowUpdateListener");
58 };
59 };
60
61 class TestWaterMarkFlagChangeListener : public IWaterMarkFlagChangedListener {
62 public:
OnWaterMarkFlagUpdate(bool showWaterMark)63 void OnWaterMarkFlagUpdate(bool showWaterMark) override
64 {
65 WLOGI("TestWaterMarkFlagChangeListener");
66 };
67 };
68
69 class TestGestureNavigationEnabledChangedListener : public IGestureNavigationEnabledChangedListener {
70 public:
OnGestureNavigationEnabledUpdate(bool enable)71 void OnGestureNavigationEnabledUpdate(bool enable) override
72 {
73 WLOGI("TestGestureNavigationEnabledChangedListener");
74 };
75 };
76
77 class WindowManagerTest : public testing::Test {
78 public:
79 static void SetUpTestCase();
80 static void TearDownTestCase();
81 void SetUp() override;
82 void TearDown() override;
83 };
84
SetUpTestCase()85 void WindowManagerTest::SetUpTestCase()
86 {
87 }
88
TearDownTestCase()89 void WindowManagerTest::TearDownTestCase()
90 {
91 }
92
SetUp()93 void WindowManagerTest::SetUp()
94 {
95 }
96
TearDown()97 void WindowManagerTest::TearDown()
98 {
99 }
100
101 namespace {
102 /**
103 * @tc.name: Create01
104 * @tc.desc: Create window with no WindowName and no abilityToken
105 * @tc.type: FUNC
106 */
107 HWTEST_F(WindowManagerTest, GetVisibilityWindowInfo01, Function | SmallTest | Level2)
108 {
109 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
110 std::vector<sptr<WindowVisibilityInfo>> infos;
111 infos.clear();
112 EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
113 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetVisibilityWindowInfo(infos));
114 EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
115 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetVisibilityWindowInfo(infos));
116 }
117
118 /**
119 * @tc.name: ToggleShownStateForAllAppWindows
120 * @tc.desc: ToggleShownStateForAllAppWindows ok
121 * @tc.type: FUNC
122 */
123 HWTEST_F(WindowManagerTest, ToggleShownStateForAllAppWindows, Function | SmallTest | Level2)
124 {
125 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
126 EXPECT_CALL(m->Mock(), ToggleShownStateForAllAppWindows()).Times(1).WillOnce(Return(WMError::WM_OK));
127 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().ToggleShownStateForAllAppWindows());
128 }
129
130 /**
131 * @tc.name: Create01
132 * @tc.desc: Create window with no WindowName and no abilityToken
133 * @tc.type: FUNC
134 */
135 HWTEST_F(WindowManagerTest, GetAccessibilityWindowInfo01, Function | SmallTest | Level2)
136 {
137 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
138 std::vector<sptr<AccessibilityWindowInfo>> infos;
139 infos.clear();
140 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
141 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
142 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
143 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
144 }
145
146 /**
147 * @tc.name: RegisterCameraFloatWindowChangedListener01
148 * @tc.desc: check RegisterCameraFloatWindowChangedListener
149 * @tc.type: FUNC
150 */
151 HWTEST_F(WindowManagerTest, RegisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2)
152 {
153 auto& windowManager = WindowManager::GetInstance();
154 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
155 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
156 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = nullptr;
157 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
158 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(nullptr));
159
160 sptr<TestCameraFloatWindowChangedListener> listener = new TestCameraFloatWindowChangedListener();
161 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
162 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
163 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(listener));
164
165 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
166 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
167 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
168
169 // to check that the same listner can not be registered twice
170 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
171 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
172
173 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
174 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
175 }
176 /**
177 * @tc.name: UnregisterCameraFloatWindowChangedListener01
178 * @tc.desc: check UnregisterCameraFloatWindowChangedListener
179 * @tc.type: FUNC
180 */
181 HWTEST_F(WindowManagerTest, UnregisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2)
182 {
183 auto& windowManager = WindowManager::GetInstance();
184 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
185 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
186 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = new WindowManagerAgent();
187 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
188
189 // check nullpter
190 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraFloatWindowChangedListener(nullptr));
191
192 sptr<TestCameraFloatWindowChangedListener> listener1 = new TestCameraFloatWindowChangedListener();
193 sptr<TestCameraFloatWindowChangedListener> listener2 = new TestCameraFloatWindowChangedListener();
194 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
195
196 windowManager.RegisterCameraFloatWindowChangedListener(listener1);
197 windowManager.RegisterCameraFloatWindowChangedListener(listener2);
198 ASSERT_EQ(2, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
199
200 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
201
202 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
203 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
204 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener2));
205 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
206 ASSERT_EQ(nullptr, windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_);
207
208 windowManager.pImpl_->cameraFloatWindowChangedListeners_.emplace_back(listener1);
209 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
210 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
211
212 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
213 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
214 }
215
216 /**
217 * @tc.name: RegisterVisibilityChangedListener01
218 * @tc.desc: check RegisterVisibilityChangedListener
219 * @tc.type: FUNC
220 */
221 HWTEST_F(WindowManagerTest, RegisterVisibilityChangedListener01, Function | SmallTest | Level2)
222 {
223 auto& windowManager = WindowManager::GetInstance();
224 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
225 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
226 windowManager.pImpl_->windowVisibilityListenerAgent_ = nullptr;
227 windowManager.pImpl_->windowVisibilityListeners_.clear();
228 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(nullptr));
229
230 sptr<TestVisibilityChangedListener> listener = new TestVisibilityChangedListener();
231 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
232 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
233 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(listener));
234 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
235
236 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
237 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
238 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
239
240 // to check that the same listner can not be registered twice
241 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
242 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
243
244 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
245 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
246 }
247 /**
248 * @tc.name: UnregisterVisibilityChangedListener01
249 * @tc.desc: check UnregisterVisibilityChangedListener
250 * @tc.type: FUNC
251 */
252 HWTEST_F(WindowManagerTest, UnregisterVisibilityChangedListener01, Function | SmallTest | Level2)
253 {
254 auto& windowManager = WindowManager::GetInstance();
255 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
256 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
257 windowManager.pImpl_->windowVisibilityListenerAgent_ = new WindowManagerAgent();
258 windowManager.pImpl_->windowVisibilityListeners_.clear();
259
260 // check nullpter
261 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityChangedListener(nullptr));
262
263 sptr<TestVisibilityChangedListener> listener1 = new TestVisibilityChangedListener();
264 sptr<TestVisibilityChangedListener> listener2 = new TestVisibilityChangedListener();
265
266 windowManager.RegisterVisibilityChangedListener(listener1);
267 windowManager.RegisterVisibilityChangedListener(listener2);
268 ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityListeners_.size());
269
270 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
271 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
272 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
273 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener2));
274 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
275 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
276
277 windowManager.pImpl_->windowVisibilityListeners_.emplace_back(listener1);
278 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
279 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
280
281 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
282 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
283 }
284
285 /**
286 * @tc.name: RegisterWindowUpdateListener01
287 * @tc.desc: check RegisterWindowUpdateListener
288 * @tc.type: FUNC
289 */
290 HWTEST_F(WindowManagerTest, RegisterWindowUpdateListener01, Function | SmallTest | Level2)
291 {
292 auto& windowManager = WindowManager::GetInstance();
293 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
294 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
295 windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
296 windowManager.pImpl_->windowUpdateListeners_.clear();
297 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr));
298
299 sptr<TestWindowUpdateListener> listener = new TestWindowUpdateListener();
300 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
301 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
302 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener));
303 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
304
305 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
306 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
307 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
308
309 // to check that the same listner can not be registered twice
310 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
311 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
312
313 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
314 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
315 }
316 /**
317 * @tc.name: UnregisterWindowUpdateListener01
318 * @tc.desc: check UnregisterWindowUpdateListener
319 * @tc.type: FUNC
320 */
321 HWTEST_F(WindowManagerTest, UnregisterWindowUpdateListener01, Function | SmallTest | Level2)
322 {
323 auto& windowManager = WindowManager::GetInstance();
324 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
325 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
326 windowManager.pImpl_->windowUpdateListenerAgent_ = new WindowManagerAgent();
327 windowManager.pImpl_->windowUpdateListeners_.clear();
328
329 // check nullpter
330 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr));
331
332 sptr<TestWindowUpdateListener> listener1 = new TestWindowUpdateListener();
333 sptr<TestWindowUpdateListener> listener2 = new TestWindowUpdateListener();
334 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
335
336 windowManager.RegisterWindowUpdateListener(listener1);
337 windowManager.RegisterWindowUpdateListener(listener2);
338 ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
339
340 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
341 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
342 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
343 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2));
344 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
345 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
346
347 windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
348 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
349 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
350
351 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
352 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
353 }
354
355 /**
356 * @tc.name: RegisterSystemBarChangedListener01
357 * @tc.desc: check RegisterSystemBarChangedListener
358 * @tc.type: FUNC
359 */
360 HWTEST_F(WindowManagerTest, RegisterSystemBarChangedListener01, Function | SmallTest | Level2)
361 {
362 auto& windowManager = WindowManager::GetInstance();
363 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
364 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
365 windowManager.pImpl_->systemBarChangedListenerAgent_ = nullptr;
366 windowManager.pImpl_->systemBarChangedListeners_.clear();
367 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(nullptr));
368
369 sptr<ISystemBarChangedListener> listener = new TestSystemBarChangedListener();
370 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
371 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
372 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(listener));
373 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
374
375 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
376 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
377 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
378
379 // to check that the same listner can not be registered twice
380 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
381 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
382
383 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
384 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
385 }
386 /**
387 * @tc.name: UnregisterSystemBarChangedListener01
388 * @tc.desc: check UnregisterSystemBarChangedListener
389 * @tc.type: FUNC
390 */
391 HWTEST_F(WindowManagerTest, UnregisterSystemBarChangedListener01, Function | SmallTest | Level2)
392 {
393 auto& windowManager = WindowManager::GetInstance();
394 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
395 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
396 windowManager.pImpl_->systemBarChangedListenerAgent_ = new WindowManagerAgent();
397 windowManager.pImpl_->systemBarChangedListeners_.clear();
398 // check nullpter
399 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterSystemBarChangedListener(nullptr));
400
401 sptr<TestSystemBarChangedListener> listener1 = new TestSystemBarChangedListener();
402 sptr<TestSystemBarChangedListener> listener2 = new TestSystemBarChangedListener();
403 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
404
405 windowManager.RegisterSystemBarChangedListener(listener1);
406 windowManager.RegisterSystemBarChangedListener(listener2);
407 ASSERT_EQ(2, windowManager.pImpl_->systemBarChangedListeners_.size());
408
409
410 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
411 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
412 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
413 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener2));
414 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
415 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
416
417 windowManager.pImpl_->systemBarChangedListeners_.push_back(listener1);
418 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
419 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
420
421 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
422 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
423 }
424
425 /**
426 * @tc.name: RegisterWaterMarkListener01
427 * @tc.desc: check RegisterWaterMarkListener
428 * @tc.type: FUNC
429 */
430 HWTEST_F(WindowManagerTest, RegisterWaterMarkFlagChangedListener01, Function | SmallTest | Level2)
431 {
432 auto& windowManager = WindowManager::GetInstance();
433
434 windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
435 windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
436
437 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(nullptr));
438
439 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
440 sptr<TestWaterMarkFlagChangeListener> listener = new TestWaterMarkFlagChangeListener();
441 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
442
443 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(listener));
444 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
445 ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
446
447 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
448 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
449 ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
450 ASSERT_NE(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
451
452 // to check that the same listner can not be registered twice
453 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
454 ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
455 }
456
457 /**
458 * @tc.name: UnregisterWaterMarkFlagChangedListener01
459 * @tc.desc: check UnregisterWaterMarkFlagChangedListener
460 * @tc.type: FUNC
461 */
462 HWTEST_F(WindowManagerTest, UnregisterWaterMarkFlagChangedListener01, Function | SmallTest | Level2)
463 {
464 auto& windowManager = WindowManager::GetInstance();
465 windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
466 windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
467 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
468
469 // check nullpter
470 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWaterMarkFlagChangedListener(nullptr));
471
472 sptr<TestWaterMarkFlagChangeListener> listener1 = new TestWaterMarkFlagChangeListener();
473 sptr<TestWaterMarkFlagChangeListener> listener2 = new TestWaterMarkFlagChangeListener();
474 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
475
476 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
477 windowManager.RegisterWaterMarkFlagChangedListener(listener1);
478 windowManager.RegisterWaterMarkFlagChangedListener(listener2);
479 ASSERT_EQ(2, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
480
481 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
482 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
483 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener2));
484 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
485 ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
486
487 // if agent == nullptr, it can not be crashed.
488 windowManager.pImpl_->waterMarkFlagChangeListeners_.push_back(listener1);
489 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
490 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
491 }
492
493
494 /**
495 * @tc.name: RegisterGestureNavigationEnabledChangedListener
496 * @tc.desc: check RegisterGestureNavigationEnabledChangedListener
497 * @tc.type: FUNC
498 */
499 HWTEST_F(WindowManagerTest, RegisterGestureNavigationEnabledChangedListener, Function | SmallTest | Level2)
500 {
501 auto& windowManager = WindowManager::GetInstance();
502
503 windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
504 windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
505
506 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(nullptr));
507
508 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
509 sptr<TestGestureNavigationEnabledChangedListener> listener = new TestGestureNavigationEnabledChangedListener();
510 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
511
512 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
513 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
514 ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
515
516 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
517 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
518 ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
519 ASSERT_NE(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
520
521 // to check that the same listner can not be registered twice
522 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
523 ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
524 }
525
526 /**
527 * @tc.name: UnregisterGestureNavigationEnabledChangedListener
528 * @tc.desc: check UnregisterGestureNavigationEnabledChangedListener
529 * @tc.type: FUNC
530 */
531 HWTEST_F(WindowManagerTest, UnregisterGestureNavigationEnabledChangedListener, Function | SmallTest | Level2)
532 {
533 auto& windowManager = WindowManager::GetInstance();
534 windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
535 windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
536 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
537
538 // check nullpter
539 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterGestureNavigationEnabledChangedListener(nullptr));
540
541 sptr<TestGestureNavigationEnabledChangedListener> listener1 = new TestGestureNavigationEnabledChangedListener();
542 sptr<TestGestureNavigationEnabledChangedListener> listener2 = new TestGestureNavigationEnabledChangedListener();
543 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM,
544 windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
545
546 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
547 windowManager.RegisterGestureNavigationEnabledChangedListener(listener1);
548 windowManager.RegisterGestureNavigationEnabledChangedListener(listener2);
549 ASSERT_EQ(2, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
550
551 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
552 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
553 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener2));
554 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
555 ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
556
557 // if agent == nullptr, it can not be crashed.
558 windowManager.pImpl_->gestureNavigationEnabledListeners_.push_back(listener1);
559 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
560 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
561 }
562
563 /**
564 * @tc.name: GetFocusWindowInfo
565 * @tc.desc: window GetFocusWindowInfo
566 * @tc.type: FUNC
567 */
568 HWTEST_F(WindowManagerTest, GetFocusWindowInfo, Function | SmallTest | Level2)
569 {
570 FocusChangeInfo focusInfo;
571 auto ret = 0;
572 WindowManager::GetInstance().GetFocusWindowInfo(focusInfo);
573 ASSERT_EQ(0, ret);
574 }
575 }
576 } // namespace Rosen
577 } // namespace OHOS