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 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
171 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
172 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
173
174 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
175 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
176 }
177
178 /**
179 * @tc.name: UnregisterCameraFloatWindowChangedListener01
180 * @tc.desc: check UnregisterCameraFloatWindowChangedListener
181 * @tc.type: FUNC
182 */
183 HWTEST_F(WindowManagerTest, UnregisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2)
184 {
185 auto& windowManager = WindowManager::GetInstance();
186 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
187 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
188 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = new WindowManagerAgent();
189 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
190
191 // check nullpter
192 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraFloatWindowChangedListener(nullptr));
193
194 sptr<TestCameraFloatWindowChangedListener> listener1 = new TestCameraFloatWindowChangedListener();
195 sptr<TestCameraFloatWindowChangedListener> listener2 = new TestCameraFloatWindowChangedListener();
196 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
197
198 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
199 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
200 windowManager.RegisterCameraFloatWindowChangedListener(listener1);
201 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
202 windowManager.RegisterCameraFloatWindowChangedListener(listener2);
203 ASSERT_EQ(2, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
204
205 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
206
207
208 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
209 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener2));
210 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
211 ASSERT_EQ(nullptr, windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_);
212
213 windowManager.pImpl_->cameraFloatWindowChangedListeners_.emplace_back(listener1);
214 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
215 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
216
217 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
218 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
219 }
220
221 /**
222 * @tc.name: RegisterVisibilityChangedListener01
223 * @tc.desc: check RegisterVisibilityChangedListener
224 * @tc.type: FUNC
225 */
226 HWTEST_F(WindowManagerTest, RegisterVisibilityChangedListener01, Function | SmallTest | Level2)
227 {
228 auto& windowManager = WindowManager::GetInstance();
229 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
230 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
231 windowManager.pImpl_->windowVisibilityListenerAgent_ = nullptr;
232 windowManager.pImpl_->windowVisibilityListeners_.clear();
233 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(nullptr));
234
235 sptr<TestVisibilityChangedListener> listener = new TestVisibilityChangedListener();
236 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
237 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
238 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(listener));
239 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
240
241 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
242 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
243 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
244
245 // to check that the same listner can not be registered twice
246 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
247 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
248 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
249
250 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
251 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
252 }
253
254 /**
255 * @tc.name: UnregisterVisibilityChangedListener01
256 * @tc.desc: check UnregisterVisibilityChangedListener
257 * @tc.type: FUNC
258 */
259 HWTEST_F(WindowManagerTest, UnregisterVisibilityChangedListener01, Function | SmallTest | Level2)
260 {
261 auto& windowManager = WindowManager::GetInstance();
262 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
263 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
264 windowManager.pImpl_->windowVisibilityListenerAgent_ = new WindowManagerAgent();
265 windowManager.pImpl_->windowVisibilityListeners_.clear();
266
267 // check nullpter
268 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityChangedListener(nullptr));
269
270 sptr<TestVisibilityChangedListener> listener1 = new TestVisibilityChangedListener();
271 sptr<TestVisibilityChangedListener> listener2 = new TestVisibilityChangedListener();
272
273 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
274 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
275 windowManager.RegisterVisibilityChangedListener(listener1);
276 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
277 windowManager.RegisterVisibilityChangedListener(listener2);
278 ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityListeners_.size());
279
280 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
281 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
282 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener2));
283 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
284 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
285
286 windowManager.pImpl_->windowVisibilityListeners_.emplace_back(listener1);
287 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
288 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
289
290 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
291 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
292 }
293
294 /**
295 * @tc.name: RegisterWindowUpdateListener01
296 * @tc.desc: check RegisterWindowUpdateListener
297 * @tc.type: FUNC
298 */
299 HWTEST_F(WindowManagerTest, RegisterWindowUpdateListener01, Function | SmallTest | Level2)
300 {
301 auto& windowManager = WindowManager::GetInstance();
302 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
303 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
304 windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
305 windowManager.pImpl_->windowUpdateListeners_.clear();
306 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr));
307
308 sptr<TestWindowUpdateListener> listener = new TestWindowUpdateListener();
309 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
310 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
311 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener));
312 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
313
314 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
315 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
316 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
317
318 // to check that the same listner can not be registered twice
319 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
320 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
321 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
322
323 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
324 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
325 }
326
327 /**
328 * @tc.name: UnregisterWindowUpdateListener01
329 * @tc.desc: check UnregisterWindowUpdateListener
330 * @tc.type: FUNC
331 */
332 HWTEST_F(WindowManagerTest, UnregisterWindowUpdateListener01, Function | SmallTest | Level2)
333 {
334 auto& windowManager = WindowManager::GetInstance();
335 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
336 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
337 windowManager.pImpl_->windowUpdateListenerAgent_ = new WindowManagerAgent();
338 windowManager.pImpl_->windowUpdateListeners_.clear();
339
340 // check nullpter
341 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr));
342
343 sptr<TestWindowUpdateListener> listener1 = new TestWindowUpdateListener();
344 sptr<TestWindowUpdateListener> listener2 = new TestWindowUpdateListener();
345 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
346
347 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
348 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
349 windowManager.RegisterWindowUpdateListener(listener1);
350 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
351 windowManager.RegisterWindowUpdateListener(listener2);
352 ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
353
354 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
355 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
356 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2));
357 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
358 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
359
360 windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
361 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
362 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
363
364 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
365 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
366 }
367
368 /**
369 * @tc.name: RegisterSystemBarChangedListener01
370 * @tc.desc: check RegisterSystemBarChangedListener
371 * @tc.type: FUNC
372 */
373 HWTEST_F(WindowManagerTest, RegisterSystemBarChangedListener01, Function | SmallTest | Level2)
374 {
375 auto& windowManager = WindowManager::GetInstance();
376 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
377 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
378 windowManager.pImpl_->systemBarChangedListenerAgent_ = nullptr;
379 windowManager.pImpl_->systemBarChangedListeners_.clear();
380 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(nullptr));
381
382 sptr<ISystemBarChangedListener> listener = new TestSystemBarChangedListener();
383 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
384 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
385 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(listener));
386 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
387
388 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
389 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
390 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
391
392 // to check that the same listner can not be registered twice
393 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
394 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
395 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
396
397 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
398 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
399 }
400
401 /**
402 * @tc.name: UnregisterSystemBarChangedListener01
403 * @tc.desc: check UnregisterSystemBarChangedListener
404 * @tc.type: FUNC
405 */
406 HWTEST_F(WindowManagerTest, UnregisterSystemBarChangedListener01, Function | SmallTest | Level2)
407 {
408 auto& windowManager = WindowManager::GetInstance();
409 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
410 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
411 windowManager.pImpl_->systemBarChangedListenerAgent_ = new WindowManagerAgent();
412 windowManager.pImpl_->systemBarChangedListeners_.clear();
413 // check nullpter
414 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterSystemBarChangedListener(nullptr));
415
416 sptr<TestSystemBarChangedListener> listener1 = new TestSystemBarChangedListener();
417 sptr<TestSystemBarChangedListener> listener2 = new TestSystemBarChangedListener();
418 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
419
420 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
421 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
422 windowManager.RegisterSystemBarChangedListener(listener1);
423 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
424 windowManager.RegisterSystemBarChangedListener(listener2);
425 ASSERT_EQ(2, windowManager.pImpl_->systemBarChangedListeners_.size());
426
427
428 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
429 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
430 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener2));
431 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
432 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
433
434 windowManager.pImpl_->systemBarChangedListeners_.push_back(listener1);
435 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
436 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
437
438 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
439 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
440 }
441
442 /**
443 * @tc.name: RegisterWaterMarkListener01
444 * @tc.desc: check RegisterWaterMarkListener
445 * @tc.type: FUNC
446 */
447 HWTEST_F(WindowManagerTest, RegisterWaterMarkFlagChangedListener01, Function | SmallTest | Level2)
448 {
449 auto& windowManager = WindowManager::GetInstance();
450
451 windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
452 windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
453
454 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(nullptr));
455
456 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
457 sptr<TestWaterMarkFlagChangeListener> listener = new TestWaterMarkFlagChangeListener();
458 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
459
460 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(listener));
461 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
462 ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
463
464 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
465 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
466 ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
467 ASSERT_NE(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
468
469 // to check that the same listner can not be registered twice
470 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
471 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
472 ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
473 }
474
475 /**
476 * @tc.name: UnregisterWaterMarkFlagChangedListener01
477 * @tc.desc: check UnregisterWaterMarkFlagChangedListener
478 * @tc.type: FUNC
479 */
480 HWTEST_F(WindowManagerTest, UnregisterWaterMarkFlagChangedListener01, Function | SmallTest | Level2)
481 {
482 auto& windowManager = WindowManager::GetInstance();
483 windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
484 windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
485 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
486
487 // check nullpter
488 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWaterMarkFlagChangedListener(nullptr));
489
490 sptr<TestWaterMarkFlagChangeListener> listener1 = new TestWaterMarkFlagChangeListener();
491 sptr<TestWaterMarkFlagChangeListener> listener2 = new TestWaterMarkFlagChangeListener();
492 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
493
494 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
495 windowManager.RegisterWaterMarkFlagChangedListener(listener1);
496 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
497 windowManager.RegisterWaterMarkFlagChangedListener(listener2);
498 ASSERT_EQ(2, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
499
500 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
501 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
502 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener2));
503 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
504 ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
505
506 // if agent == nullptr, it can not be crashed.
507 windowManager.pImpl_->waterMarkFlagChangeListeners_.push_back(listener1);
508 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
509 ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
510 }
511
512 /**
513 * @tc.name: RegisterGestureNavigationEnabledChangedListener
514 * @tc.desc: check RegisterGestureNavigationEnabledChangedListener
515 * @tc.type: FUNC
516 */
517 HWTEST_F(WindowManagerTest, RegisterGestureNavigationEnabledChangedListener, Function | SmallTest | Level2)
518 {
519 auto& windowManager = WindowManager::GetInstance();
520
521 windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
522 windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
523
524 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(nullptr));
525
526 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
527 sptr<TestGestureNavigationEnabledChangedListener> listener = new TestGestureNavigationEnabledChangedListener();
528 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
529
530 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
531 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
532 ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
533
534 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
535 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
536 ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
537 ASSERT_NE(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
538
539 // to check that the same listner can not be registered twice
540 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
541 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
542 ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
543 }
544
545 /**
546 * @tc.name: UnregisterGestureNavigationEnabledChangedListener
547 * @tc.desc: check UnregisterGestureNavigationEnabledChangedListener
548 * @tc.type: FUNC
549 */
550 HWTEST_F(WindowManagerTest, UnregisterGestureNavigationEnabledChangedListener, Function | SmallTest | Level2)
551 {
552 auto& windowManager = WindowManager::GetInstance();
553 windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
554 windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
555 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
556
557 // check nullpter
558 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterGestureNavigationEnabledChangedListener(nullptr));
559
560 sptr<TestGestureNavigationEnabledChangedListener> listener1 = new TestGestureNavigationEnabledChangedListener();
561 sptr<TestGestureNavigationEnabledChangedListener> listener2 = new TestGestureNavigationEnabledChangedListener();
562 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM,
563 windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
564
565 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
566 windowManager.RegisterGestureNavigationEnabledChangedListener(listener1);
567 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
568 windowManager.RegisterGestureNavigationEnabledChangedListener(listener2);
569 ASSERT_EQ(2, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
570
571 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
572 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
573 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener2));
574 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
575 ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
576
577 // if agent == nullptr, it can not be crashed.
578 windowManager.pImpl_->gestureNavigationEnabledListeners_.push_back(listener1);
579 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
580 ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
581 }
582
583 /**
584 * @tc.name: GetFocusWindowInfo
585 * @tc.desc: window GetFocusWindowInfo
586 * @tc.type: FUNC
587 */
588 HWTEST_F(WindowManagerTest, GetFocusWindowInfo, Function | SmallTest | Level2)
589 {
590 FocusChangeInfo focusInfo;
591 auto ret = 0;
592 WindowManager::GetInstance().GetFocusWindowInfo(focusInfo);
593 ASSERT_EQ(0, ret);
594 }
595
596 /**
597 * @tc.name: MinimizeAllAppWindows
598 * @tc.desc: window MinimizeAllAppWindows
599 * @tc.type: FUNC
600 */
601 HWTEST_F(WindowManagerTest, MinimizeAllAppWindows, Function | SmallTest | Level2)
602 {
603 DisplayId displayId = 0;
604 WMError ret = WindowManager::GetInstance().MinimizeAllAppWindows(displayId);
605 ASSERT_EQ(ret, WMError::WM_OK);
606 }
607
608 /**
609 * @tc.name: SetWindowLayoutMode
610 * @tc.desc: window SetWindowLayoutMode
611 * @tc.type: FUNC
612 */
613 HWTEST_F(WindowManagerTest, SetWindowLayoutMode, Function | SmallTest | Level2)
614 {
615 WindowLayoutMode mode = WindowLayoutMode::BASE;
616 WMError ret = WindowManager::GetInstance().SetWindowLayoutMode(mode);
617 ASSERT_EQ(ret, WMError::WM_OK);
618 }
619
620 /**
621 * @tc.name: UpdateCameraFloatWindowStatus
622 * @tc.desc: UpdateCameraFloatWindowStatus
623 * @tc.type: FUNC
624 */
625 HWTEST_F(WindowManagerTest, UpdateCameraFloatWindowStatus, Function | SmallTest | Level2)
626 {
627 uint32_t accessTokenId = 0;
628 bool isShowing = true;
629 auto ret = 0;
630 WindowManager::GetInstance().UpdateCameraFloatWindowStatus(accessTokenId, isShowing);
631 ASSERT_EQ(0, ret);
632 }
633
634 /**
635 * @tc.name: NotifyWaterMarkFlagChangedResult
636 * @tc.desc: NotifyWaterMarkFlagChangedResult
637 * @tc.type: FUNC
638 */
639 HWTEST_F(WindowManagerTest, NotifyWaterMarkFlagChangedResult, Function | SmallTest | Level2)
640 {
641 bool showwatermark = true;
642 auto ret = 0;
643 WindowManager::GetInstance().NotifyWaterMarkFlagChangedResult(showwatermark);
644 ASSERT_EQ(0, ret);
645 }
646
647 /**
648 * @tc.name: NotifyGestureNavigationEnabledResult
649 * @tc.desc: NotifyGestureNavigationEnabledResult
650 * @tc.type: FUNC
651 */
652 HWTEST_F(WindowManagerTest, NotifyGestureNavigationEnabledResult, Function | SmallTest | Level2)
653 {
654 bool enable = true;
655 auto ret = 0;
656 WindowManager::GetInstance().NotifyGestureNavigationEnabledResult(enable);
657 ASSERT_EQ(0, ret);
658 }
659
660 /**
661 * @tc.name: DumpSessionAll
662 * @tc.desc: DumpSessionAll
663 * @tc.type: FUNC
664 */
665 HWTEST_F(WindowManagerTest, DumpSessionAll, Function | SmallTest | Level2)
666 {
667 std::vector<std::string> infos;
668 infos.push_back("DumpSessionWithId");
669 WMError res = WindowManager::GetInstance().DumpSessionAll(infos);
670 ASSERT_EQ(WMError::WM_OK, res);
671 }
672
673 /**
674 * @tc.name: DumpSessionWithId
675 * @tc.desc: DumpSessionWithId
676 * @tc.type: FUNC
677 */
678 HWTEST_F(WindowManagerTest, DumpSessionWithId, Function | SmallTest | Level2)
679 {
680 std::vector<std::string> infos;
681 infos.push_back("DumpSessionWithId");
682 int32_t persistentId = 0;
683 WMError res = WindowManager::GetInstance().DumpSessionWithId(persistentId, infos);
684 ASSERT_EQ(WMError::WM_OK, res);
685 }
686 }
687 } // namespace Rosen
688 } // namespace OHOS