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 WLOGFI("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 WLOGFI("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 WLOGFI("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 WLOGFI("TestWindowUpdateListener");
58 };
59 };
60
61 class WindowManagerTest : public testing::Test {
62 public:
63 static void SetUpTestCase();
64 static void TearDownTestCase();
65 void SetUp() override;
66 void TearDown() override;
67 };
68
SetUpTestCase()69 void WindowManagerTest::SetUpTestCase()
70 {
71 }
72
TearDownTestCase()73 void WindowManagerTest::TearDownTestCase()
74 {
75 }
76
SetUp()77 void WindowManagerTest::SetUp()
78 {
79 }
80
TearDown()81 void WindowManagerTest::TearDown()
82 {
83 }
84
85 namespace {
86 /**
87 * @tc.name: Create01
88 * @tc.desc: Create window with no WindowName and no abilityToken
89 * @tc.type: FUNC
90 */
91 HWTEST_F(WindowManagerTest, GetVisibilityWindowInfo01, Function | SmallTest | Level2)
92 {
93 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
94 std::vector<sptr<WindowVisibilityInfo>> infos;
95 infos.clear();
96 EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
97 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetVisibilityWindowInfo(infos));
98 EXPECT_CALL(m->Mock(), GetVisibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
99 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetVisibilityWindowInfo(infos));
100 }
101
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, GetAccessibilityWindowInfo01, Function | SmallTest | Level2)
108 {
109 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
110 std::vector<sptr<AccessibilityWindowInfo>> infos;
111 infos.clear();
112 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
113 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
114 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
115 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
116 }
117
118 /**
119 * @tc.name: RegisterCameraFloatWindowChangedListener01
120 * @tc.desc: check RegisterCameraFloatWindowChangedListener
121 * @tc.type: FUNC
122 */
123 HWTEST_F(WindowManagerTest, RegisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2)
124 {
125 auto& windowManager = WindowManager::GetInstance();
126 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
127 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
128 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = nullptr;
129 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
130 ASSERT_EQ(false, windowManager.RegisterCameraFloatWindowChangedListener(nullptr));
131
132 sptr<TestCameraFloatWindowChangedListener> listener = new TestCameraFloatWindowChangedListener();
133 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
134 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(false));
135 ASSERT_EQ(false, windowManager.RegisterCameraFloatWindowChangedListener(listener));
136
137 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(true));
138 ASSERT_EQ(true, windowManager.RegisterCameraFloatWindowChangedListener(listener));
139 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
140
141 // to check that the same listner can not be registered twice
142 ASSERT_EQ(true, windowManager.RegisterCameraFloatWindowChangedListener(listener));
143 ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
144
145 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
146 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
147 }
148 /**
149 * @tc.name: UnregisterCameraFloatWindowChangedListener01
150 * @tc.desc: check UnregisterCameraFloatWindowChangedListener
151 * @tc.type: FUNC
152 */
153 HWTEST_F(WindowManagerTest, UnregisterCameraFloatWindowChangedListener01, Function | SmallTest | Level2)
154 {
155 auto& windowManager = WindowManager::GetInstance();
156 auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
157 auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
158 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = new WindowManagerAgent();
159 windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
160
161 // check nullpter
162 ASSERT_EQ(false, windowManager.UnregisterCameraFloatWindowChangedListener(nullptr));
163
164 sptr<TestCameraFloatWindowChangedListener> listener1 = new TestCameraFloatWindowChangedListener();
165 sptr<TestCameraFloatWindowChangedListener> listener2 = new TestCameraFloatWindowChangedListener();
166 ASSERT_EQ(true, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
167
168 windowManager.RegisterCameraFloatWindowChangedListener(listener1);
169 windowManager.RegisterCameraFloatWindowChangedListener(listener2);
170 ASSERT_EQ(2, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
171
172 ASSERT_EQ(true, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
173
174 ASSERT_EQ(false, windowManager.UnregisterCameraFloatWindowChangedListener(listener2));
175 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
176 ASSERT_EQ(nullptr, windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_);
177
178 windowManager.pImpl_->cameraFloatWindowChangedListeners_.emplace_back(listener1);
179 ASSERT_EQ(true, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
180 ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
181
182 windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
183 windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
184 }
185
186 /**
187 * @tc.name: RegisterVisibilityChangedListener01
188 * @tc.desc: check RegisterVisibilityChangedListener
189 * @tc.type: FUNC
190 */
191 HWTEST_F(WindowManagerTest, RegisterVisibilityChangedListener01, Function | SmallTest | Level2)
192 {
193 auto& windowManager = WindowManager::GetInstance();
194 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
195 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
196 windowManager.pImpl_->windowVisibilityListenerAgent_ = nullptr;
197 windowManager.pImpl_->windowVisibilityListeners_.clear();
198 ASSERT_EQ(false, windowManager.RegisterVisibilityChangedListener(nullptr));
199
200 sptr<TestVisibilityChangedListener> listener = new TestVisibilityChangedListener();
201 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
202 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(false));
203 ASSERT_EQ(false, windowManager.RegisterVisibilityChangedListener(listener));
204 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
205
206 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(true));
207 ASSERT_EQ(true, windowManager.RegisterVisibilityChangedListener(listener));
208 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
209
210 // to check that the same listner can not be registered twice
211 ASSERT_EQ(true, windowManager.RegisterVisibilityChangedListener(listener));
212 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
213
214 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
215 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
216 }
217 /**
218 * @tc.name: UnregisterVisibilityChangedListener01
219 * @tc.desc: check UnregisterVisibilityChangedListener
220 * @tc.type: FUNC
221 */
222 HWTEST_F(WindowManagerTest, UnregisterVisibilityChangedListener01, Function | SmallTest | Level2)
223 {
224 auto& windowManager = WindowManager::GetInstance();
225 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
226 auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
227 windowManager.pImpl_->windowVisibilityListenerAgent_ = new WindowManagerAgent();
228 windowManager.pImpl_->windowVisibilityListeners_.clear();
229
230 // check nullpter
231 ASSERT_EQ(false, windowManager.UnregisterVisibilityChangedListener(nullptr));
232
233 sptr<TestVisibilityChangedListener> listener1 = new TestVisibilityChangedListener();
234 sptr<TestVisibilityChangedListener> listener2 = new TestVisibilityChangedListener();
235
236 windowManager.RegisterVisibilityChangedListener(listener1);
237 windowManager.RegisterVisibilityChangedListener(listener2);
238 ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityListeners_.size());
239
240 ASSERT_EQ(true, windowManager.UnregisterVisibilityChangedListener(listener1));
241 ASSERT_EQ(false, windowManager.UnregisterVisibilityChangedListener(listener2));
242 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
243 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
244
245 windowManager.pImpl_->windowVisibilityListeners_.emplace_back(listener1);
246 ASSERT_EQ(true, windowManager.UnregisterVisibilityChangedListener(listener1));
247 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
248
249 windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
250 windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
251 }
252
253 /**
254 * @tc.name: RegisterWindowUpdateListener01
255 * @tc.desc: check RegisterWindowUpdateListener
256 * @tc.type: FUNC
257 */
258 HWTEST_F(WindowManagerTest, RegisterWindowUpdateListener01, Function | SmallTest | Level2)
259 {
260 auto& windowManager = WindowManager::GetInstance();
261 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
262 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
263 windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
264 windowManager.pImpl_->windowUpdateListeners_.clear();
265 ASSERT_EQ(false, windowManager.RegisterWindowUpdateListener(nullptr));
266
267 sptr<TestWindowUpdateListener> listener = new TestWindowUpdateListener();
268 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
269 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(false));
270 ASSERT_EQ(false, windowManager.RegisterWindowUpdateListener(listener));
271 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
272
273 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(true));
274 ASSERT_EQ(true, windowManager.RegisterWindowUpdateListener(listener));
275 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
276
277 // to check that the same listner can not be registered twice
278 ASSERT_EQ(true, windowManager.RegisterWindowUpdateListener(listener));
279 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
280
281 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
282 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
283 }
284 /**
285 * @tc.name: UnregisterWindowUpdateListener01
286 * @tc.desc: check UnregisterWindowUpdateListener
287 * @tc.type: FUNC
288 */
289 HWTEST_F(WindowManagerTest, UnregisterWindowUpdateListener01, Function | SmallTest | Level2)
290 {
291 auto& windowManager = WindowManager::GetInstance();
292 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
293 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
294 windowManager.pImpl_->windowUpdateListenerAgent_ = new WindowManagerAgent();
295 windowManager.pImpl_->windowUpdateListeners_.clear();
296
297 // check nullpter
298 ASSERT_EQ(false, windowManager.UnregisterWindowUpdateListener(nullptr));
299
300 sptr<TestWindowUpdateListener> listener1 = new TestWindowUpdateListener();
301 sptr<TestWindowUpdateListener> listener2 = new TestWindowUpdateListener();
302 ASSERT_EQ(true, windowManager.UnregisterWindowUpdateListener(listener1));
303
304 windowManager.RegisterWindowUpdateListener(listener1);
305 windowManager.RegisterWindowUpdateListener(listener2);
306 ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
307
308 ASSERT_EQ(true, windowManager.UnregisterWindowUpdateListener(listener1));
309
310 ASSERT_EQ(false, windowManager.UnregisterWindowUpdateListener(listener2));
311 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
312 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
313
314 windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
315 ASSERT_EQ(true, windowManager.UnregisterWindowUpdateListener(listener1));
316 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
317
318 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
319 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
320 }
321
322 /**
323 * @tc.name: RegisterSystemBarChangedListener01
324 * @tc.desc: check RegisterSystemBarChangedListener
325 * @tc.type: FUNC
326 */
327 HWTEST_F(WindowManagerTest, RegisterSystemBarChangedListener01, Function | SmallTest | Level2)
328 {
329 auto& windowManager = WindowManager::GetInstance();
330 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
331 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
332 windowManager.pImpl_->systemBarChangedListenerAgent_ = nullptr;
333 windowManager.pImpl_->systemBarChangedListeners_.clear();
334 ASSERT_EQ(false, windowManager.RegisterSystemBarChangedListener(nullptr));
335
336 sptr<ISystemBarChangedListener> listener = new TestSystemBarChangedListener();
337 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
338 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(false));
339 ASSERT_EQ(false, windowManager.RegisterSystemBarChangedListener(listener));
340 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
341
342 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(true));
343 ASSERT_EQ(true, windowManager.RegisterSystemBarChangedListener(listener));
344 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
345
346 // to check that the same listner can not be registered twice
347 ASSERT_EQ(true, windowManager.RegisterSystemBarChangedListener(listener));
348 ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
349
350 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
351 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
352 }
353 /**
354 * @tc.name: UnregisterSystemBarChangedListener01
355 * @tc.desc: check UnregisterSystemBarChangedListener
356 * @tc.type: FUNC
357 */
358 HWTEST_F(WindowManagerTest, UnregisterSystemBarChangedListener01, Function | SmallTest | Level2)
359 {
360 auto& windowManager = WindowManager::GetInstance();
361 auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
362 auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
363 windowManager.pImpl_->systemBarChangedListenerAgent_ = new WindowManagerAgent();
364 windowManager.pImpl_->systemBarChangedListeners_.clear();
365 // check nullpter
366 ASSERT_EQ(false, windowManager.UnregisterSystemBarChangedListener(nullptr));
367
368 sptr<TestSystemBarChangedListener> listener1 = new TestSystemBarChangedListener();
369 sptr<TestSystemBarChangedListener> listener2 = new TestSystemBarChangedListener();
370 ASSERT_EQ(true, windowManager.UnregisterSystemBarChangedListener(listener1));
371
372 windowManager.RegisterSystemBarChangedListener(listener1);
373 windowManager.RegisterSystemBarChangedListener(listener2);
374 ASSERT_EQ(2, windowManager.pImpl_->systemBarChangedListeners_.size());
375
376
377 ASSERT_EQ(true, windowManager.UnregisterSystemBarChangedListener(listener1));
378 ASSERT_EQ(false, windowManager.UnregisterSystemBarChangedListener(listener2));
379 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
380 ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
381
382 windowManager.pImpl_->systemBarChangedListeners_.push_back(listener1);
383 ASSERT_EQ(true, windowManager.UnregisterSystemBarChangedListener(listener1));
384 ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
385
386 windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
387 windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
388 }
389 /**
390 * @tc.name: ToggleShownStateForAllAppWindows
391 * @tc.desc: ToggleShownStateForAllAppWindows ok
392 * @tc.type: FUNC
393 */
394 HWTEST_F(WindowManagerTest, ToggleShownStateForAllAppWindows, Function | SmallTest | Level2)
395 {
396 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
397 EXPECT_CALL(m->Mock(), ToggleShownStateForAllAppWindows()).Times(1).WillOnce(Return(WMError::WM_OK));
398 ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().ToggleShownStateForAllAppWindows());
399 }
400 }
401 } // namespace Rosen
402 } // namespace OHOS
403