1 /*
2 * Copyright (c) 2023 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 "mock_window_adapter_lite.h"
18 #include "singleton_mocker.h"
19 #include "window_manager_lite.cpp"
20 #include "wm_common.h"
21 #include "session/host/include/scene_session.h"
22 #include "common/include/window_session_property.h"
23 #include "session_manager/include/scene_session_manager.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27 namespace OHOS::Rosen {
28 using Mocker = SingletonMocker<WindowAdapterLite, MockWindowAdapterLite>;
29
30 class TestCameraWindowChangedListener : public ICameraWindowChangedListener {
31 public:
OnCameraWindowChange(uint32_t accessTokenId,bool isShowing)32 void OnCameraWindowChange(uint32_t accessTokenId, bool isShowing) override {};
33 };
34
35 class TestWindowModeChangedListener : public IWindowModeChangedListener {
36 public:
OnWindowModeUpdate(WindowModeType mode)37 void OnWindowModeUpdate(WindowModeType mode) override {};
38 };
39
40 class TestWMSConnectionChangedListener : public IWMSConnectionChangedListener {
41 public:
OnConnected(int32_t userId,int32_t screenId)42 void OnConnected(int32_t userId, int32_t screenId) override {};
OnDisconnected(int32_t userId,int32_t screenId)43 void OnDisconnected(int32_t userId, int32_t screenId) override {};
44 };
45
46 class TestFocusChangedListener : public IFocusChangedListener {
47 public:
OnFocused(const sptr<FocusChangeInfo> & focusChangeInfo)48 void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo) override {};
OnUnfocused(const sptr<FocusChangeInfo> & focusChangeInfo)49 void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo) override {};
50 };
51
52 class TestDrawingContentChangedListener : public IDrawingContentChangedListener {
53 public:
OnWindowDrawingContentChanged(const std::vector<sptr<WindowDrawingContentInfo>> & windowDrawingInfo)54 void OnWindowDrawingContentChanged(const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingInfo) override {
55 };
56 };
57
58 class TestVisibilityChangedListener : public IVisibilityChangedListener {
59 public:
OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>> & windowVisibilityInfo)60 void OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfo) override {};
61 };
62
63 class IWMSConnectionChangedListenerSon : public IWMSConnectionChangedListener {
64 public:
OnConnected(int32_t userId,int32_t screenId)65 void OnConnected(int32_t userId, int32_t screenId) override {};
OnDisconnected(int32_t userId,int32_t screenId)66 void OnDisconnected(int32_t userId, int32_t screenId) override {};
67 };
68
69 class TestWindowStyleChangedListener : public IWindowStyleChangedListener {
70 public:
OnWindowStyleUpdate(WindowStyleType styleType)71 void OnWindowStyleUpdate(WindowStyleType styleType)
72 {
73 TLOGI(WmsLogTag::DMS, "TestWindowStyleChangedListener");
74 }
75 };
76
77 class TestPiPStateChangedListener : public IPiPStateChangedListener {
78 public:
OnPiPStateChanged(const std::string & bundleName,bool isForeground)79 void OnPiPStateChanged(const std::string& bundleName, bool isForeground) override {}
80 };
81
82 class TestWindowUpdateListener : public IWindowUpdateListener {
83 public:
OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>> & infos,WindowUpdateType type)84 void OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>>& infos, WindowUpdateType type) override
85 {
86 WLOGI("TestWindowUpdateListener");
87 }
88 };
89
90 class TestWindowVisibilityStateListener : public IWindowInfoChangedListener {
91 public:
OnWindowInfoChanged(const std::vector<std::unordered_map<WindowInfoKey,std::any>> & windowInfoList)92 void OnWindowInfoChanged(
93 const std::vector<std::unordered_map<WindowInfoKey, std::any>>& windowInfoList) override
94 {
95 WLOGI("TestWindowUpdateListener");
96 };
97 };
98
99 class TestIKeyboardCallingWindowDisplayChangedListener : public IKeyboardCallingWindowDisplayChangedListener {
100 public:
OnCallingWindowDisplayChanged(const CallingWindowInfo & callingWindowInfo)101 void OnCallingWindowDisplayChanged(const CallingWindowInfo& callingWindowInfo)
102 {
103 info = callingWindowInfo;
104 isNotified = true;
105 }
106
107 private:
108 CallingWindowInfo info = {0, -1, 0, 0};
109 bool isNotified = false;
110 };
111
112 class WindowManagerLiteTest : public testing::Test {
113 public:
114 static void SetUpTestCase();
115 static void TearDownTestCase();
116 void SetUp() override;
117 void TearDown() override;
118
119 // keyboard
120 bool CheckCallingWindowInfo(const CallingWindowInfo& desiredInfo, const CallingWindowInfo& actualInfo);
121 };
122
SetUpTestCase()123 void WindowManagerLiteTest::SetUpTestCase() {}
124
TearDownTestCase()125 void WindowManagerLiteTest::TearDownTestCase() {}
126
SetUp()127 void WindowManagerLiteTest::SetUp() {}
128
TearDown()129 void WindowManagerLiteTest::TearDown() {}
130
CheckCallingWindowInfo(const CallingWindowInfo & desiredInfo,const CallingWindowInfo & actualInfo)131 bool WindowManagerLiteTest::CheckCallingWindowInfo(
132 const CallingWindowInfo& desiredInfo, const CallingWindowInfo& actualInfo)
133 {
134 return desiredInfo.windowId_ == actualInfo.windowId_ && desiredInfo.callingPid_ == actualInfo.callingPid_ &&
135 desiredInfo.displayId_ == actualInfo.displayId_ && desiredInfo.userId_ == actualInfo.userId_;
136 }
137
138 namespace {
139 /**
140 * @tc.name: GetFocusWindowInfo
141 * @tc.desc: using windowManagerLite to get focus info
142 * @tc.type: FUNC
143 */
144 HWTEST_F(WindowManagerLiteTest, GetFocusWindowInfo, Function | SmallTest | Level2)
145 {
146 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
147 FocusChangeInfo infosInput;
148 FocusChangeInfo infosResult;
149 infosResult.pid_ = 10;
150 infosResult.uid_ = 11;
151 infosResult.displayId_ = 12;
152 infosResult.windowId_ = 13;
153 EXPECT_CALL(m->Mock(), GetFocusWindowInfo(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<0>(infosResult), Return()));
154 WindowManagerLite::GetInstance().GetFocusWindowInfo(infosInput);
155 ASSERT_EQ(infosInput.windowId_, infosResult.windowId_);
156 ASSERT_EQ(infosInput.uid_, infosResult.uid_);
157 ASSERT_EQ(infosInput.pid_, infosResult.pid_);
158 ASSERT_EQ(infosInput.displayId_, infosResult.displayId_);
159 }
160
161 /**
162 * @tc.name: UpdateCameraWindowStatus01
163 * @tc.desc: UpdateCameraWindowStatus
164 * @tc.type: FUNC
165 */
166 HWTEST_F(WindowManagerLiteTest, UpdateCameraWindowStatus01, Function | SmallTest | Level2)
167 {
168 uint32_t accessTokenId = 0;
169 bool isShowing = true;
170 auto ret = 0;
171 WindowManagerLite::GetInstance().UpdateCameraWindowStatus(accessTokenId, isShowing);
172 ASSERT_EQ(0, ret);
173 }
174
175 /**
176 * @tc.name: UpdateCameraWindowStatus02
177 * @tc.desc: UpdateCameraWindowStatus
178 * @tc.type: FUNC
179 */
180 HWTEST_F(WindowManagerLiteTest, UpdateCameraWindowStatus02, Function | SmallTest | Level2)
181 {
182 auto& windowManager = WindowManagerLite::GetInstance();
183 sptr<TestCameraWindowChangedListener> listener = sptr<TestCameraWindowChangedListener>::MakeSptr();
184 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
185 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
186 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
187
188 uint32_t accessTokenId = 0;
189 bool isShowing = true;
190 auto ret = 0;
191 WindowManagerLite::GetInstance().UpdateCameraWindowStatus(accessTokenId, isShowing);
192 ASSERT_EQ(0, ret);
193 }
194
195 /**
196 * @tc.name: RegisterCameraWindowChangedListener01
197 * @tc.desc: check RegisterCameraWindowChangedListener
198 * @tc.type: FUNC
199 */
200 HWTEST_F(WindowManagerLiteTest, RegisterCameraWindowChangedListener01, Function | SmallTest | Level2)
201 {
202 auto& windowManager = WindowManagerLite::GetInstance();
203 auto oldWindowManagerAgent = windowManager.pImpl_->cameraWindowChangedListenerAgent_;
204 auto oldListeners = windowManager.pImpl_->cameraWindowChangedListeners_;
205 windowManager.pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
206 windowManager.pImpl_->cameraWindowChangedListeners_.clear();
207 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraWindowChangedListener(nullptr));
208
209 sptr<TestCameraWindowChangedListener> listener = sptr<TestCameraWindowChangedListener>::MakeSptr();
210 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
211 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
212 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraWindowChangedListener(listener));
213
214 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
215 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
216 ASSERT_EQ(1, windowManager.pImpl_->cameraWindowChangedListeners_.size());
217
218 // to check that the same listner can not be registered twice
219 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
220 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
221 ASSERT_EQ(1, windowManager.pImpl_->cameraWindowChangedListeners_.size());
222
223 windowManager.pImpl_->cameraWindowChangedListenerAgent_ = oldWindowManagerAgent;
224 windowManager.pImpl_->cameraWindowChangedListeners_ = oldListeners;
225 }
226
227 /**
228 * @tc.name: UnregisterCameraWindowChangedListener01
229 * @tc.desc: check UnregisterCameraWindowChangedListener
230 * @tc.type: FUNC
231 */
232 HWTEST_F(WindowManagerLiteTest, UnregisterCameraWindowChangedListener01, Function | SmallTest | Level2)
233 {
234 auto& windowManager = WindowManagerLite::GetInstance();
235 auto oldWindowManagerAgent = windowManager.pImpl_->cameraWindowChangedListenerAgent_;
236 auto oldListeners = windowManager.pImpl_->cameraWindowChangedListeners_;
237 windowManager.pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
238 windowManager.pImpl_->cameraWindowChangedListeners_.clear();
239
240 // check nullpter
241 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraWindowChangedListener(nullptr));
242
243 sptr<TestCameraWindowChangedListener> listener1 = sptr<TestCameraWindowChangedListener>::MakeSptr();
244 sptr<TestCameraWindowChangedListener> listener2 = sptr<TestCameraWindowChangedListener>::MakeSptr();
245 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
246
247 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
248 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
249 windowManager.RegisterCameraWindowChangedListener(listener1);
250 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
251 windowManager.RegisterCameraWindowChangedListener(listener2);
252 ASSERT_EQ(2, windowManager.pImpl_->cameraWindowChangedListeners_.size());
253 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
254
255 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
256 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener2));
257 ASSERT_EQ(0, windowManager.pImpl_->cameraWindowChangedListeners_.size());
258 ASSERT_EQ(nullptr, windowManager.pImpl_->cameraWindowChangedListenerAgent_);
259
260 windowManager.pImpl_->cameraWindowChangedListeners_.emplace_back(listener1);
261 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
262 ASSERT_EQ(0, windowManager.pImpl_->cameraWindowChangedListeners_.size());
263
264 windowManager.pImpl_->cameraWindowChangedListenerAgent_ = oldWindowManagerAgent;
265 windowManager.pImpl_->cameraWindowChangedListeners_ = oldListeners;
266 }
267
268 /**
269 * @tc.name: Test01
270 * @tc.desc: check UnregisterCameraWindowChangedListener
271 * @tc.type: FUNC
272 */
273 HWTEST_F(WindowManagerLiteTest, Test01, Function | SmallTest | Level2)
274 {
275 sptr<IFocusChangedListener> listener = nullptr;
276 auto ret1 = WindowManagerLite::GetInstance().RegisterFocusChangedListener(listener);
277 auto ret2 = WindowManagerLite::GetInstance().UnregisterFocusChangedListener(listener);
278 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret1);
279 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret2);
280 sptr<IVisibilityChangedListener> listener1 = nullptr;
281 auto ret3 = WindowManagerLite::GetInstance().RegisterVisibilityChangedListener(listener1);
282 auto ret4 = WindowManagerLite::GetInstance().UnregisterVisibilityChangedListener(listener1);
283 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret3);
284 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret4);
285 std::vector<sptr<WindowVisibilityInfo>> infos;
286 ASSERT_EQ(WMError::WM_OK, WindowManagerLite::GetInstance().GetVisibilityWindowInfo(infos));
287 sptr<IDrawingContentChangedListener> listener2 = nullptr;
288 auto ret5 = WindowManagerLite::GetInstance().RegisterDrawingContentChangedListener(listener2);
289 auto ret6 = WindowManagerLite::GetInstance().UnregisterDrawingContentChangedListener(listener2);
290 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret5);
291 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret6);
292 sptr<IWindowModeChangedListener> listener3 = nullptr;
293 auto ret7 = WindowManagerLite::GetInstance().RegisterWindowModeChangedListener(listener3);
294 auto ret8 = WindowManagerLite::GetInstance().UnregisterWindowModeChangedListener(listener3);
295 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret7);
296 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret8);
297 sptr<IWMSConnectionChangedListener> listener4 = nullptr;
298 WMError res9 = WindowManagerLite::GetInstance().RegisterWMSConnectionChangedListener(listener4);
299 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, res9);
300 WMError res10 = WindowManagerLite::GetInstance().UnregisterWMSConnectionChangedListener();
301 ASSERT_EQ(WMError::WM_OK, res10);
302 }
303
304 /**
305 * @tc.name: Test04
306 * @tc.desc: Test04
307 * @tc.type: FUNC
308 */
309 HWTEST_F(WindowManagerLiteTest, Test04, Function | SmallTest | Level2)
310 {
311 WindowManagerLite lite;
312 sptr<FocusChangeInfo> focusChangeInfo = nullptr;
313 ASSERT_NE(lite.pImpl_, nullptr);
314 lite.pImpl_->NotifyFocused(focusChangeInfo);
315 lite.pImpl_->NotifyUnfocused(focusChangeInfo);
316 focusChangeInfo = sptr<FocusChangeInfo>::MakeSptr();
317 lite.pImpl_->NotifyFocused(focusChangeInfo);
318 lite.pImpl_->NotifyUnfocused(focusChangeInfo);
319 std::vector<sptr<WindowVisibilityInfo>> windowVisibilityInfos;
320 lite.pImpl_->NotifyWindowVisibilityInfoChanged(windowVisibilityInfos);
321 std::vector<sptr<WindowDrawingContentInfo>> windowDrawingContentInfos;
322 lite.pImpl_->NotifyWindowDrawingContentInfoChanged(windowDrawingContentInfos);
323 lite.pImpl_->NotifyWindowModeChange(WindowModeType::WINDOW_MODE_SPLIT);
324 }
325
326 /**
327 * @tc.name: RegisterWindowModeChangedListener02
328 * @tc.desc: check RegisterWindowModeChangedListener
329 * @tc.type: FUNC
330 */
331 HWTEST_F(WindowManagerLiteTest, RegisterWindowModeChangedListener02, Function | SmallTest | Level2)
332 {
333 auto& windowManager = WindowManagerLite::GetInstance();
334 auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
335 auto oldListeners = windowManager.pImpl_->windowModeListeners_;
336 windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
337 windowManager.pImpl_->windowModeListeners_.clear();
338 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(nullptr));
339
340 sptr<TestWindowModeChangedListener> listener = sptr<TestWindowModeChangedListener>::MakeSptr();
341 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
342 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
343 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(listener));
344
345 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
346 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
347 ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
348
349 // to check that the same listner can not be registered twice
350 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
351 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
352 ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
353
354 windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
355 windowManager.pImpl_->windowModeListeners_ = oldListeners;
356 }
357
358 /**
359 * @tc.name: UnregisterWindowModeChangedListener02
360 * @tc.desc: check UnregisterWindowModeChangedListener
361 * @tc.type: FUNC
362 */
363 HWTEST_F(WindowManagerLiteTest, UnregisterWindowModeChangedListener02, Function | SmallTest | Level2)
364 {
365 auto& windowManager = WindowManagerLite::GetInstance();
366 auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
367 auto oldListeners = windowManager.pImpl_->windowModeListeners_;
368 windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
369 windowManager.pImpl_->windowModeListeners_.clear();
370
371 // check nullpter
372 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowModeChangedListener(nullptr));
373
374 sptr<TestWindowModeChangedListener> listener1 = sptr<TestWindowModeChangedListener>::MakeSptr();
375 sptr<TestWindowModeChangedListener> listener2 = sptr<TestWindowModeChangedListener>::MakeSptr();
376 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
377
378 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
379 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
380 windowManager.RegisterWindowModeChangedListener(listener1);
381 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
382 windowManager.RegisterWindowModeChangedListener(listener2);
383 ASSERT_EQ(2, windowManager.pImpl_->windowModeListeners_.size());
384 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
385
386 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
387 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener2));
388 ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
389 ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
390
391 windowManager.pImpl_->windowModeListeners_.emplace_back(listener1);
392 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
393 ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
394
395 windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
396 windowManager.pImpl_->windowModeListeners_ = oldListeners;
397 }
398
399 /**
400 * @tc.name: RegisterWMSConnectionChangedListener02
401 * @tc.desc: check RegisterWMSConnectionChangedListener
402 * @tc.type: FUNC
403 */
404 HWTEST_F(WindowManagerLiteTest, RegisterWMSConnectionChangedListener02, Function | SmallTest | Level2)
405 {
406 auto& windowManager = WindowManagerLite::GetInstance();
407 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWMSConnectionChangedListener(nullptr));
408
409 sptr<TestWMSConnectionChangedListener> listener = sptr<TestWMSConnectionChangedListener>::MakeSptr();
410 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
411 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWMSConnectionChangedListener(listener));
412
413 windowManager.pImpl_->wmsConnectionChangedListener_ = nullptr;
414 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWMSConnectionChangedListener(listener));
415 }
416
417 /**
418 * @tc.name: GetMainWindowInfos
419 * @tc.desc: get top main window info
420 * @tc.type: FUNC
421 */
422 HWTEST_F(WindowManagerLiteTest, GetMainWindowInfos, Function | SmallTest | Level2)
423 {
424 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
425 std::vector<MainWindowInfo> topNInfo;
426 std::vector<MainWindowInfo> topNInfoResult;
427 MainWindowInfo info1;
428 info1.pid_ = 1900;
429 info1.bundleName_ = "calendar";
430
431 MainWindowInfo info2;
432 info1.pid_ = 1901;
433 info1.bundleName_ = "settings";
434
435 MainWindowInfo info3;
436 info1.pid_ = 1902;
437 info1.bundleName_ = "photos";
438
439 topNInfoResult.push_back(info1);
440 topNInfoResult.push_back(info2);
441 topNInfoResult.push_back(info3);
442
443 int32_t topN = 3;
444
445 EXPECT_CALL(m->Mock(), GetMainWindowInfos(_, _))
446 .Times(1)
447 .WillOnce(DoAll(SetArgReferee<1>(topNInfoResult), Return(WMError::WM_OK)));
448
449 WindowManagerLite::GetInstance().GetMainWindowInfos(topN, topNInfo);
450
451 auto it1 = topNInfo.begin();
452 auto it2 = topNInfoResult.begin();
453 for (; it1 != topNInfo.end() && it2 != topNInfoResult.end(); it1++, it2++) {
454 ASSERT_EQ(it1->pid_, it2->pid_);
455 ASSERT_EQ(it1->bundleName_, it2->bundleName_);
456 }
457 }
458
459 /**
460 * @tc.name: TestUpdateFocusChangeInfo
461 * @tc.desc: TestUpdateFocusChangeInfo
462 * @tc.type: FUNC
463 */
464 HWTEST_F(WindowManagerLiteTest, TestUpdateFocusChangeInfo, Function | SmallTest | Level2)
465 {
466 sptr<FocusChangeInfo> focusChangeInfo = nullptr;
467 WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo, true);
468 sptr<FocusChangeInfo> focusChangeInfo1 = sptr<FocusChangeInfo>::MakeSptr();
469 WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo1, true);
470 WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo1, false);
471 std::vector<sptr<WindowVisibilityInfo>> infos;
472 WindowManagerLite::GetInstance().UpdateWindowVisibilityInfo(infos);
473 std::vector<sptr<WindowDrawingContentInfo>> infos1;
474 WindowManagerLite::GetInstance().UpdateWindowDrawingContentInfo(infos1);
475 WindowManagerLite lite;
476 lite.destroyed_ = true;
477 lite.OnRemoteDied();
478 lite.destroyed_ = false;
479 lite.OnRemoteDied();
480 ASSERT_EQ(nullptr, lite.pImpl_->focusChangedListenerAgent_);
481 ASSERT_EQ(nullptr, lite.pImpl_->windowUpdateListenerAgent_);
482 ASSERT_EQ(nullptr, lite.pImpl_->windowDrawingContentListenerAgent_);
483 }
484
485 /**
486 * @tc.name: NotifyFocusedWithUn
487 * @tc.desc: NotifyFocused With MotifyUnFocused
488 * @tc.type: FUNC
489 */
490 HWTEST_F(WindowManagerLiteTest, NotifyFocusedWithUn, Function | SmallTest | Level2)
491 {
492 WindowManagerLite lite;
493 sptr<FocusChangeInfo> focusChangeInfo = nullptr;
494 lite.pImpl_->NotifyFocused(focusChangeInfo);
495 lite.pImpl_->NotifyUnfocused(focusChangeInfo);
496 ASSERT_EQ(focusChangeInfo, nullptr);
497 focusChangeInfo = sptr<FocusChangeInfo>::MakeSptr();
498 lite.pImpl_->focusChangedListeners_.push_back(nullptr);
499 sptr<TestFocusChangedListener> testFocusChangedListener = sptr<TestFocusChangedListener>::MakeSptr();
500 lite.pImpl_->focusChangedListeners_.push_back(testFocusChangedListener);
501 lite.pImpl_->NotifyFocused(focusChangeInfo);
502 lite.pImpl_->NotifyUnfocused(focusChangeInfo);
503 ASSERT_NE(focusChangeInfo, nullptr);
504 }
505
506 /**
507 * @tc.name: NotifyWindowDrawingContentInfoChanged02
508 * @tc.desc: NotifyWindowDrawingContentInfoChanged
509 * @tc.type: FUNC
510 */
511 HWTEST_F(WindowManagerLiteTest, NotifyWindowDrawingContentInfoChanged02, Function | SmallTest | Level2)
512 {
513 WindowManagerLite lite;
514 auto& windowManager = WindowManagerLite::GetInstance();
515 sptr<TestDrawingContentChangedListener> listener = sptr<TestDrawingContentChangedListener>::MakeSptr();
516 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
517 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
518 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDrawingContentChangedListener(listener));
519
520 std::vector<sptr<WindowDrawingContentInfo>> windowDrawingContentInfos;
521 lite.pImpl_->NotifyWindowDrawingContentInfoChanged(windowDrawingContentInfos);
522 }
523
524 /**
525 * @tc.name: NotifyWindowModeChange02
526 * @tc.desc: NotifyWindowModeChange
527 * @tc.type: FUNC
528 */
529 HWTEST_F(WindowManagerLiteTest, NotifyWindowModeChange02, Function | SmallTest | Level2)
530 {
531 WindowManagerLite lite;
532 auto& windowManager = WindowManagerLite::GetInstance();
533 sptr<TestWindowModeChangedListener> listener = sptr<TestWindowModeChangedListener>::MakeSptr();
534 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
535 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
536 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
537
538 lite.pImpl_->NotifyWindowModeChange(WindowModeType::WINDOW_MODE_SPLIT);
539 }
540
541 /**
542 * @tc.name: NotifyWindowVisibilityInfoChanged02
543 * @tc.desc: NotifyWindowVisibilityInfoChanged
544 * @tc.type: FUNC
545 */
546 HWTEST_F(WindowManagerLiteTest, NotifyWindowVisibilityInfoChanged02, Function | SmallTest | Level2)
547 {
548 WindowManagerLite lite;
549 auto& windowManager = WindowManagerLite::GetInstance();
550 sptr<TestVisibilityChangedListener> listener = sptr<TestVisibilityChangedListener>::MakeSptr();
551 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
552 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
553 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
554
555 std::vector<sptr<WindowVisibilityInfo>> windowVisibilityInfos;
556 lite.pImpl_->NotifyWindowVisibilityInfoChanged(windowVisibilityInfos);
557 }
558
559 /**
560 * @tc.name: NotifyUnfocused01
561 * @tc.desc: NotifyUnfocused
562 * @tc.type: FUNC
563 */
564 HWTEST_F(WindowManagerLiteTest, NotifyUnfocused01, Function | SmallTest | Level2)
565 {
566 WindowManagerLite lite;
567 auto& windowManager = WindowManagerLite::GetInstance();
568 sptr<FocusChangeInfo> focusChangeInfo = sptr<FocusChangeInfo>::MakeSptr();
569
570 sptr<TestFocusChangedListener> listener = sptr<TestFocusChangedListener>::MakeSptr();
571 ASSERT_TRUE(listener != nullptr);
572 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
573 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
574 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterFocusChangedListener(listener));
575 lite.pImpl_->NotifyUnfocused(focusChangeInfo);
576 }
577
578 /**
579 * @tc.name: GetAllMainWindowInfos001
580 * @tc.desc: GetAllMainWindowInfos001
581 * @tc.type: FUNC
582 */
583 HWTEST_F(WindowManagerLiteTest, GetAllMainWindowInfos001, Function | SmallTest | Level2)
584 {
585 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
586 std::vector<MainWindowInfo> infos;
587 std::vector<MainWindowInfo> infosResult;
588 MainWindowInfo info1;
589 info1.pid_ = 1900;
590 info1.bundleName_ = "calendar";
591
592 MainWindowInfo info2;
593 info1.pid_ = 1901;
594 info1.bundleName_ = "settings";
595
596 MainWindowInfo info3;
597 info1.pid_ = 1902;
598 info1.bundleName_ = "photos";
599
600 infosResult.push_back(info1);
601 infosResult.push_back(info2);
602 infosResult.push_back(info3);
603
604 EXPECT_CALL(m->Mock(), GetAllMainWindowInfos(_))
605 .Times(1)
606 .WillOnce(DoAll(SetArgReferee<0>(infosResult), Return(WMError::WM_OK)));
607
608 auto errorCode = WindowManagerLite::GetInstance().GetAllMainWindowInfos(infos);
609 ASSERT_EQ(WMError::WM_OK, errorCode);
610 auto it1 = infos.begin();
611 auto it2 = infosResult.begin();
612 for (; it1 != infos.end() && it2 != infosResult.end(); it1++, it2++) {
613 ASSERT_EQ(it1->pid_, it2->pid_);
614 ASSERT_EQ(it1->bundleName_, it2->bundleName_);
615 ASSERT_EQ(it1->persistentId_, it2->persistentId_);
616 ASSERT_EQ(it1->bundleType_, it2->bundleType_);
617 }
618 }
619
620 /**
621 * @tc.name: GetAllMainWindowInfos002
622 * @tc.desc: GetAllMainWindowInfos002
623 * @tc.type: FUNC
624 */
625 HWTEST_F(WindowManagerLiteTest, GetAllMainWindowInfos002, Function | SmallTest | Level2)
626 {
627 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
628 std::vector<MainWindowInfo> infos;
629 MainWindowInfo info1;
630 info1.pid_ = 1900;
631 info1.bundleName_ = "calendar";
632 infos.push_back(info1);
633
634 EXPECT_CALL(m->Mock(), GetAllMainWindowInfos(_)).Times(0).WillOnce(DoAll(Return(WMError::WM_OK)));
635
636 auto errorCode = WindowManagerLite::GetInstance().GetAllMainWindowInfos(infos);
637 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, errorCode);
638 }
639
640 /**
641 * @tc.name: ClearMainSessions001
642 * @tc.desc: ClearMainSessions001
643 * @tc.type: FUNC
644 */
645 HWTEST_F(WindowManagerLiteTest, ClearMainSessions001, Function | SmallTest | Level2)
646 {
647 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
648 std::vector<int32_t> persistentIds;
649
650 EXPECT_CALL(m->Mock(), ClearMainSessions(_)).Times(0).WillOnce(Return(WMError::WM_OK));
651
652 auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds);
653 ASSERT_EQ(WMError::WM_OK, errorCode);
654 }
655
656 /**
657 * @tc.name: ClearMainSessions002
658 * @tc.desc: ClearMainSessions002
659 * @tc.type: FUNC
660 */
661 HWTEST_F(WindowManagerLiteTest, ClearMainSessions002, Function | SmallTest | Level2)
662 {
663 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
664 std::vector<int32_t> persistentIds = { 1, 2 };
665
666 EXPECT_CALL(m->Mock(), ClearMainSessions(_)).Times(1).WillOnce(Return(WMError::WM_OK));
667
668 auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds);
669 ASSERT_EQ(WMError::WM_OK, errorCode);
670 }
671
672 /**
673 * @tc.name: ClearMainSessions003
674 * @tc.desc: ClearMainSessions003
675 * @tc.type: FUNC
676 */
677 HWTEST_F(WindowManagerLiteTest, ClearMainSessions003, Function | SmallTest | Level2)
678 {
679 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
680 std::vector<int32_t> persistentIds;
681 std::vector<int32_t> clearFailedIds;
682 EXPECT_CALL(m->Mock(), ClearMainSessions(_, _)).Times(0).WillOnce(Return(WMError::WM_OK));
683
684 auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds, clearFailedIds);
685 ASSERT_EQ(WMError::WM_OK, errorCode);
686 }
687
688 /**
689 * @tc.name: ClearMainSessions004
690 * @tc.desc: ClearMainSessions004
691 * @tc.type: FUNC
692 */
693 HWTEST_F(WindowManagerLiteTest, ClearMainSessions004, Function | SmallTest | Level2)
694 {
695 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
696 std::vector<int32_t> persistentIds = { 1, 2 };
697 std::vector<int32_t> clearFailedIds;
698 EXPECT_CALL(m->Mock(), ClearMainSessions(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
699
700 auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds, clearFailedIds);
701 ASSERT_EQ(WMError::WM_OK, errorCode);
702 }
703
704 /**
705 * @tc.name: GetWindowModeType
706 * @tc.desc: GetWindowModeType
707 * @tc.type: FUNC
708 */
709 HWTEST_F(WindowManagerLiteTest, GetWindowModeType, Function | SmallTest | Level2)
710 {
711 WindowModeType windowModeType = WindowModeType::WINDOW_MODE_SPLIT_FLOATING;
712 auto ret = WindowManagerLite::GetInstance().GetWindowModeType(windowModeType);
713 ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
714 }
715
716 /**
717 * @tc.name: RaiseWindowToTop
718 * @tc.desc: RaiseWindowToTop
719 * @tc.type: FUNC
720 */
721 HWTEST_F(WindowManagerLiteTest, RaiseWindowToTop, Function | SmallTest | Level2)
722 {
723 auto ret = WindowManagerLite::GetInstance().RaiseWindowToTop(0);
724 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
725 }
726
727 /**
728 * @tc.name: NotifyWMSConnected01
729 * @tc.desc: NotifyWMSConnected
730 * @tc.type: FUNC
731 */
732 HWTEST_F(WindowManagerLiteTest, NotifyWMSConnected01, Function | SmallTest | Level2)
733 {
734 WindowManagerLite::GetInstance().pImpl_->wmsConnectionChangedListener_ = nullptr;
735 WindowManagerLite::GetInstance().pImpl_->NotifyWMSConnected(0, 0);
736 WindowManagerLite::GetInstance().pImpl_->NotifyWMSDisconnected(0, 0);
737 sptr<FocusChangeInfo> focusChangeInfo = nullptr;
738 WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo, true);
739 focusChangeInfo = sptr<FocusChangeInfo>::MakeSptr();
740 ASSERT_NE(nullptr, focusChangeInfo);
741 WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo, true);
742 WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo, false);
743 std::vector<sptr<WindowVisibilityInfo>> windowVisibilityInfos;
744 WindowManagerLite::GetInstance().UpdateWindowVisibilityInfo(windowVisibilityInfos);
745 std::vector<sptr<WindowDrawingContentInfo>> windowDrawingContentInfos;
746 WindowManagerLite::GetInstance().UpdateWindowDrawingContentInfo(windowDrawingContentInfos);
747 WindowManagerLite::GetInstance().OnRemoteDied();
748 WindowManagerLite::GetInstance().OnWMSConnectionChanged(0, 0, true);
749 WindowManagerLite::GetInstance().OnWMSConnectionChanged(0, 0, false);
750 WindowModeType windowModeType = WindowModeType::WINDOW_MODE_SPLIT_FLOATING;
751 WindowManagerLite::GetInstance().UpdateWindowModeTypeInfo(windowModeType);
752 auto ret = WindowManagerLite::GetInstance().GetWindowModeType(windowModeType);
753 EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
754 }
755
756 /**
757 * @tc.name: NotifyWMSConnected02
758 * @tc.desc: NotifyWMSConnected
759 * @tc.type: FUNC
760 */
761 HWTEST_F(WindowManagerLiteTest, NotifyWMSConnected02, Function | SmallTest | Level2)
762 {
763 auto& windowManager = WindowManagerLite::GetInstance();
764 sptr<TestWMSConnectionChangedListener> listener = sptr<TestWMSConnectionChangedListener>::MakeSptr();
765 windowManager.pImpl_->wmsConnectionChangedListener_ = nullptr;
766 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
767 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWMSConnectionChangedListener(listener));
768 int32_t userId = 0;
769 int32_t screenId = 0;
770 WindowManagerLite::GetInstance().pImpl_->NotifyWMSConnected(userId, screenId);
771 WindowManagerLite::GetInstance().pImpl_->NotifyWMSDisconnected(userId, screenId);
772 }
773
774 /**
775 * @tc.name: NotifyWMSConnected03
776 * @tc.desc: NotifyWMSConnected
777 * @tc.type: FUNC
778 */
779 HWTEST_F(WindowManagerLiteTest, NotifyWMSConnected03, Function | SmallTest | Level2)
780 {
781 WindowManagerLite::GetInstance().pImpl_->wmsConnectionChangedListener_ =
782 sptr<IWMSConnectionChangedListenerSon>::MakeSptr();
783 WindowManagerLite::GetInstance().pImpl_->NotifyWMSConnected(0, 0);
784 EXPECT_NE(WindowManagerLite::GetInstance().pImpl_->wmsConnectionChangedListener_, nullptr);
785 WindowManagerLite::GetInstance().pImpl_->NotifyWMSDisconnected(0, 0);
786 EXPECT_NE(WindowManagerLite::GetInstance().pImpl_->wmsConnectionChangedListener_, nullptr);
787 }
788
789 /**
790 * @tc.name: RegisterWindowStyleChangedListener
791 * @tc.desc: check RegisterWindowStyleChangedListener
792 * @tc.type: FUNC
793 */
794 HWTEST_F(WindowManagerLiteTest, RegisterWindowStyleChangedListener, Function | SmallTest | Level2)
795 {
796 auto& windowManager = WindowManagerLite::GetInstance();
797 auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
798 auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
799 windowManager.pImpl_->windowStyleListenerAgent_ = nullptr;
800 windowManager.pImpl_->windowStyleListeners_.clear();
801 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(nullptr));
802
803 sptr<IWindowStyleChangedListener> listener = sptr<TestWindowStyleChangedListener>::MakeSptr();
804 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
805 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
806 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(listener));
807 ASSERT_EQ(nullptr, windowManager.pImpl_->windowStyleListenerAgent_);
808
809 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
810 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
811 ASSERT_EQ(1, windowManager.pImpl_->windowStyleListeners_.size());
812
813 // to check that the same listner can not be registered twice
814 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
815 ASSERT_EQ(1, windowManager.pImpl_->windowStyleListeners_.size());
816
817 windowManager.pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
818 windowManager.pImpl_->windowStyleListeners_ = oldListeners;
819 }
820
821 /**
822 * @tc.name: UnregisterWindowStyleChangedListener
823 * @tc.desc: check UnregisterWindowStyleChangedListener
824 * @tc.type: FUNC
825 */
826 HWTEST_F(WindowManagerLiteTest, UnregisterWindowStyleChangedListener, Function | SmallTest | Level2)
827 {
828 auto& windowManager = WindowManagerLite::GetInstance();
829 auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
830 auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
831 windowManager.pImpl_->windowStyleListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
832 windowManager.pImpl_->windowStyleListeners_.clear();
833 // check nullpter
834 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowStyleChangedListener(nullptr));
835
836 sptr<TestWindowStyleChangedListener> listener1 = sptr<TestWindowStyleChangedListener>::MakeSptr();
837 sptr<TestWindowStyleChangedListener> listener2 = sptr<TestWindowStyleChangedListener>::MakeSptr();
838 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
839
840 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
841 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
842 windowManager.RegisterWindowStyleChangedListener(listener1);
843 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
844 windowManager.RegisterWindowStyleChangedListener(listener2);
845 ASSERT_EQ(2, windowManager.pImpl_->windowStyleListeners_.size());
846
847 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
848 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
849 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener2));
850 ASSERT_EQ(0, windowManager.pImpl_->windowStyleListeners_.size());
851 ASSERT_EQ(nullptr, windowManager.pImpl_->windowStyleListenerAgent_);
852
853 windowManager.pImpl_->windowStyleListeners_.push_back(listener1);
854 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
855 ASSERT_EQ(0, windowManager.pImpl_->windowStyleListeners_.size());
856 windowManager.pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
857 windowManager.pImpl_->windowStyleListeners_ = oldListeners;
858 }
859
860 /**
861 * @tc.name: NotifyWindowStyleChange01
862 * @tc.desc: check NotifyWindowStyleChange
863 * @tc.type: FUNC
864 */
865 HWTEST_F(WindowManagerLiteTest, NotifyWindowStyleChange01, Function | SmallTest | Level2)
866 {
867 WindowStyleType type = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
868 auto ret = WindowManagerLite::GetInstance().NotifyWindowStyleChange(type);
869 ASSERT_EQ(WMError::WM_OK, ret);
870 }
871
872 /**
873 * @tc.name: NotifyWindowStyleChange02
874 * @tc.desc: check NotifyWindowStyleChange
875 * @tc.type: FUNC
876 */
877 HWTEST_F(WindowManagerLiteTest, NotifyWindowStyleChange02, Function | SmallTest | Level2)
878 {
879 auto& windowManager = WindowManagerLite::GetInstance();
880 sptr<IWindowStyleChangedListener> listener = sptr<TestWindowStyleChangedListener>::MakeSptr();
881 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
882 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
883 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
884
885 WindowStyleType type = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
886 auto ret = WindowManagerLite::GetInstance().NotifyWindowStyleChange(type);
887 ASSERT_EQ(WMError::WM_OK, ret);
888 }
889
890 /**
891 * @tc.name: GetWindowStyleType
892 * @tc.desc: check GetWindowStyleType
893 * @tc.type: FUNC
894 */
895 HWTEST_F(WindowManagerLiteTest, GetWindowStyleType, Function | SmallTest | Level2)
896 {
897 WindowStyleType type = WindowManagerLite::GetInstance().GetWindowStyleType();
898 ASSERT_EQ(Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT, type);
899 }
900
901 /**
902 * @tc.name: TerminateSessionByPersistentId001
903 * @tc.desc: TerminateSessionByPersistentId001
904 * @tc.type: FUNC
905 */
906 HWTEST_F(WindowManagerLiteTest, TerminateSessionByPersistentId001, Function | SmallTest | Level2)
907 {
908 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
909 int32_t persistentId = 1;
910 EXPECT_CALL(m->Mock(), TerminateSessionByPersistentId(_)).Times(1).WillOnce(Return(WMError::WM_OK));
911
912 auto errorCode = WindowManagerLite::GetInstance().TerminateSessionByPersistentId(persistentId);
913 ASSERT_EQ(WMError::WM_OK, errorCode);
914 }
915
916 /**
917 * @tc.name: TerminateSessionByPersistentId002
918 * @tc.desc: TerminateSessionByPersistentId002
919 * @tc.type: FUNC
920 */
921 HWTEST_F(WindowManagerLiteTest, TerminateSessionByPersistentId002, Function | SmallTest | Level2)
922 {
923 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
924 int32_t persistentId = 0;
925 auto errorCode = WindowManagerLite::GetInstance().TerminateSessionByPersistentId(persistentId);
926 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, errorCode);
927 }
928
929 /**
930 * @tc.name: OnRemoteDied01
931 * @tc.desc: OnRemoteDied01
932 * @tc.type: FUNC
933 */
934 HWTEST_F(WindowManagerLiteTest, OnRemoteDied01, Function | SmallTest | Level2)
935 {
936 WindowManagerLite::GetInstance().destroyed_ = true;
937 WindowManagerLite::GetInstance().OnRemoteDied();
938 ASSERT_EQ(WindowManagerLite::GetInstance().destroyed_, true);
939 }
940
941 /**
942 * @tc.name: CloseTargetFloatWindow
943 * @tc.desc: check CloseTargetFloatWindow
944 * @tc.type: FUNC
945 */
946 HWTEST_F(WindowManagerLiteTest, CloseTargetFloatWindow, Function | SmallTest | Level2)
947 {
948 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
949 std::string bundleName = "test";
950 EXPECT_CALL(m->Mock(), CloseTargetFloatWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
951
952 auto errorCode = WindowManagerLite::GetInstance().CloseTargetFloatWindow(bundleName);
953 ASSERT_EQ(WMError::WM_OK, errorCode);
954 }
955
956 /**
957 * @tc.name: RegisterPiPStateChangedListener
958 * @tc.desc: check RegisterPiPStateChangedListener
959 * @tc.type: FUNC
960 */
961 HWTEST_F(WindowManagerLiteTest, RegisterPiPStateChangedListener, Function | SmallTest | Level2)
962 {
963 auto& windowManager = WindowManagerLite::GetInstance();
964 auto oldWindowManagerAgent = windowManager.pImpl_->pipStateChangedListenerAgent_;
965 auto oldListeners = windowManager.pImpl_->pipStateChangedListeners_;
966 windowManager.pImpl_->pipStateChangedListenerAgent_ = nullptr;
967 windowManager.pImpl_->pipStateChangedListeners_.clear();
968 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterPiPStateChangedListener(nullptr));
969
970 sptr<IPiPStateChangedListener> listener = sptr<TestPiPStateChangedListener>::MakeSptr();
971 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
972 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
973 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterPiPStateChangedListener(listener));
974 ASSERT_EQ(nullptr, windowManager.pImpl_->pipStateChangedListenerAgent_);
975
976 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
977 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterPiPStateChangedListener(listener));
978 ASSERT_EQ(1, windowManager.pImpl_->pipStateChangedListeners_.size());
979
980 // to check that the same listner can not be registered twice
981 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
982 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterPiPStateChangedListener(listener));
983 ASSERT_EQ(1, windowManager.pImpl_->pipStateChangedListeners_.size());
984
985 windowManager.pImpl_->pipStateChangedListenerAgent_ = oldWindowManagerAgent;
986 windowManager.pImpl_->pipStateChangedListeners_ = oldListeners;
987 }
988
989 /**
990 * @tc.name: UnregisterPiPStateChangedListener
991 * @tc.desc: check UnregisterPiPStateChangedListener
992 * @tc.type: FUNC
993 */
994 HWTEST_F(WindowManagerLiteTest, UnregisterPiPStateChangedListener, Function | SmallTest | Level2)
995 {
996 auto& windowManager = WindowManagerLite::GetInstance();
997 auto oldWindowManagerAgent = windowManager.pImpl_->pipStateChangedListenerAgent_;
998 auto oldListeners = windowManager.pImpl_->pipStateChangedListeners_;
999 windowManager.pImpl_->pipStateChangedListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
1000 windowManager.pImpl_->pipStateChangedListeners_.clear();
1001 // check nullpter
1002 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterPiPStateChangedListener(nullptr));
1003
1004 sptr<IPiPStateChangedListener> listener1 = sptr<TestPiPStateChangedListener>::MakeSptr();
1005 sptr<IPiPStateChangedListener> listener2 = sptr<TestPiPStateChangedListener>::MakeSptr();
1006 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
1007
1008 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1009 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1010 windowManager.RegisterPiPStateChangedListener(listener1);
1011 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1012 windowManager.RegisterPiPStateChangedListener(listener2);
1013 ASSERT_EQ(2, windowManager.pImpl_->pipStateChangedListeners_.size());
1014
1015 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
1016 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1017 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener2));
1018 ASSERT_EQ(0, windowManager.pImpl_->pipStateChangedListeners_.size());
1019 ASSERT_EQ(nullptr, windowManager.pImpl_->pipStateChangedListenerAgent_);
1020
1021 windowManager.pImpl_->pipStateChangedListeners_.push_back(listener1);
1022 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
1023 ASSERT_EQ(0, windowManager.pImpl_->pipStateChangedListeners_.size());
1024 windowManager.pImpl_->pipStateChangedListenerAgent_ = oldWindowManagerAgent;
1025 windowManager.pImpl_->pipStateChangedListeners_ = oldListeners;
1026 }
1027
1028 /**
1029 * @tc.name: CloseTargetPiPWindow
1030 * @tc.desc: check CloseTargetPiPWindow
1031 * @tc.type: FUNC
1032 */
1033 HWTEST_F(WindowManagerLiteTest, CloseTargetPiPWindow, Function | SmallTest | Level2)
1034 {
1035 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1036 std::string bundleName = "test";
1037 EXPECT_CALL(m->Mock(), CloseTargetPiPWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1038
1039 auto errorCode = WindowManagerLite::GetInstance().CloseTargetPiPWindow(bundleName);
1040 ASSERT_EQ(WMError::WM_OK, errorCode);
1041 }
1042
1043 /**
1044 * @tc.name: GetCurrentPiPWindowInfo01
1045 * @tc.desc: check GetCurrentPiPWindowInfo
1046 * @tc.type: FUNC
1047 */
1048 HWTEST_F(WindowManagerLiteTest, GetCurrentPiPWindowInfo01, Function | SmallTest | Level2)
1049 {
1050 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1051 EXPECT_CALL(m->Mock(), GetCurrentPiPWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1052
1053 std::string bundleName;
1054 auto errorCode = WindowManagerLite::GetInstance().GetCurrentPiPWindowInfo(bundleName);
1055 ASSERT_EQ(WMError::WM_OK, errorCode);
1056 ASSERT_EQ("", bundleName);
1057 }
1058
1059 /**
1060 * @tc.name: GetCurrentPiPWindowInfo02
1061 * @tc.desc: check GetCurrentPiPWindowInfo
1062 * @tc.type: FUNC
1063 */
1064 HWTEST_F(WindowManagerLiteTest, GetCurrentPiPWindowInfo02, Function | SmallTest | Level2)
1065 {
1066 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1067 std::string testBundleName = "test";
1068 bool testState = true;
1069 EXPECT_CALL(m->Mock(), GetCurrentPiPWindowInfo(_))
1070 .Times(1)
1071 .WillOnce(DoAll(SetArgReferee<0>(testBundleName), Return(WMError::WM_OK)));
1072
1073 std::string bundleName;
1074 auto errorCode = WindowManagerLite::GetInstance().GetCurrentPiPWindowInfo(bundleName);
1075 ASSERT_EQ(WMError::WM_OK, errorCode);
1076 ASSERT_EQ(testBundleName, bundleName);
1077 }
1078
1079 /**
1080 * @tc.name: GetAccessibilityWindowInfo01
1081 * @tc.desc: check GetAccessibilityWindowInfo
1082 * @tc.type: FUNC
1083 */
1084 HWTEST_F(WindowManagerLiteTest, GetAccessibilityWindowInfo01, Function | SmallTest | Level2)
1085 {
1086 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1087 std::vector<sptr<AccessibilityWindowInfo>> infos;
1088 infos.clear();
1089 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1090 ASSERT_EQ(WMError::WM_OK, WindowManagerLite::GetInstance().GetAccessibilityWindowInfo(infos));
1091 EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
1092 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManagerLite::GetInstance().GetAccessibilityWindowInfo(infos));
1093 }
1094
1095 /**
1096 * @tc.name: RegisterWindowUpdateListener01
1097 * @tc.desc: check RegisterWindowUpdateListener
1098 * @tc.type: FUNC
1099 */
1100 HWTEST_F(WindowManagerLiteTest, RegisterWindowUpdateListener01, Function | SmallTest | Level2)
1101 {
1102 auto& windowManager = WindowManagerLite::GetInstance();
1103 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
1104 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
1105 windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
1106 windowManager.pImpl_->windowUpdateListeners_.clear();
1107 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr));
1108
1109 sptr<TestWindowUpdateListener> listener = sptr<TestWindowUpdateListener>::MakeSptr();
1110 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1111 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1112 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener));
1113 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
1114
1115 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1116 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
1117 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
1118
1119 // to check that the same listner can not be registered twice
1120 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1121 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
1122 ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
1123
1124 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
1125 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
1126 }
1127
1128 /**
1129 * @tc.name: UnregisterWindowUpdateListener01
1130 * @tc.desc: check UnregisterWindowUpdateListener
1131 * @tc.type: FUNC
1132 */
1133 HWTEST_F(WindowManagerLiteTest, UnregisterWindowUpdateListener01, Function | SmallTest | Level2)
1134 {
1135 auto& windowManager = WindowManagerLite::GetInstance();
1136 auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
1137 auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
1138 windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
1139 windowManager.pImpl_->windowUpdateListeners_.clear();
1140
1141 // check nullpter
1142 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr));
1143
1144 sptr<TestWindowUpdateListener> listener1 = sptr<TestWindowUpdateListener>::MakeSptr();
1145 sptr<TestWindowUpdateListener> listener2 = sptr<TestWindowUpdateListener>::MakeSptr();
1146 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
1147
1148 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1149 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1150 windowManager.RegisterWindowUpdateListener(listener1);
1151 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1152 windowManager.RegisterWindowUpdateListener(listener2);
1153 ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
1154
1155 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
1156 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1157 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2));
1158 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
1159 ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
1160
1161 windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
1162 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
1163 ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
1164
1165 windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
1166 windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
1167 }
1168
1169 /**
1170 * @tc.name: ProcessRegisterWindowInfoChangeCallback01
1171 * @tc.desc: Check ProcessRegisterWindowInfoChangeCallback
1172 * @tc.type: FUNC
1173 */
1174 HWTEST_F(WindowManagerLiteTest, ProcessRegisterWindowInfoChangeCallback01, Function | SmallTest | Level2)
1175 {
1176 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1177 WindowInfoKey observedInfo = WindowInfoKey::VISIBILITY_STATE;
1178 auto ret = WindowManagerLite::GetInstance().ProcessRegisterWindowInfoChangeCallback(observedInfo, listener);
1179 ASSERT_EQ(WMError::WM_OK, ret);
1180 ret = WindowManagerLite::GetInstance().ProcessRegisterWindowInfoChangeCallback(observedInfo, nullptr);
1181 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1182 observedInfo = WindowInfoKey::BUNDLE_NAME;
1183 ret = WindowManagerLite::GetInstance().ProcessRegisterWindowInfoChangeCallback(observedInfo, listener);
1184 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1185 }
1186
1187 /**
1188 * @tc.name: ProcessUnregisterWindowInfoChangeCallback01
1189 * @tc.desc: Check ProcessUnregisterWindowInfoChangeCallback
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(WindowManagerLiteTest, ProcessUnregisterWindowInfoChangeCallback01, Function | SmallTest | Level2)
1193 {
1194 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1195 WindowInfoKey observedInfo = WindowInfoKey::VISIBILITY_STATE;
1196 auto ret = WindowManagerLite::GetInstance().ProcessUnregisterWindowInfoChangeCallback(observedInfo, listener);
1197 ASSERT_EQ(WMError::WM_OK, ret);
1198 ret = WindowManagerLite::GetInstance().ProcessUnregisterWindowInfoChangeCallback(observedInfo, nullptr);
1199 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1200 observedInfo = WindowInfoKey::BUNDLE_NAME;
1201 ret = WindowManagerLite::GetInstance().ProcessUnregisterWindowInfoChangeCallback(observedInfo, listener);
1202 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1203 }
1204
1205 /**
1206 * @tc.name: RegisterWindowInfoChangeCallback01
1207 * @tc.desc: Check RegisterWindowInfoChangeCallback
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(WindowManagerLiteTest, RegisterWindowInfoChangeCallback01, Function | SmallTest | Level2)
1211 {
1212 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1213 auto interestInfoSizeOld = listener->GetInterestInfo().size();
1214 std::unordered_set<WindowInfoKey> observedInfo;
1215 observedInfo.insert(WindowInfoKey::VISIBILITY_STATE);
1216 auto ret = WindowManagerLite::GetInstance().RegisterWindowInfoChangeCallback(observedInfo, listener);
1217 ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
1218 ASSERT_EQ(interestInfoSizeOld + 1, listener->GetInterestInfo().size());
1219 std::unordered_set<WindowInfoKey> observedInfo1;
1220 observedInfo1.insert(WindowInfoKey::BUNDLE_NAME);
1221 ret = WindowManagerLite::GetInstance().RegisterWindowInfoChangeCallback(observedInfo1, listener);
1222 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1223 }
1224
1225 /**
1226 * @tc.name: UnregisterWindowInfoChangeCallback01
1227 * @tc.desc: Check UnregisterWindowInfoChangeCallback
1228 * @tc.type: FUNC
1229 */
1230 HWTEST_F(WindowManagerLiteTest, UnregisterWindowInfoChangeCallback01, Function | SmallTest | Level2)
1231 {
1232 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1233 auto interestInfoSizeOld = listener->GetInterestInfo().size();
1234 std::unordered_set<WindowInfoKey> observedInfo;
1235 observedInfo.insert(WindowInfoKey::VISIBILITY_STATE);
1236 auto ret = WindowManagerLite::GetInstance().UnregisterWindowInfoChangeCallback(observedInfo, listener);
1237 ASSERT_EQ(WMError::WM_OK, ret);
1238 ASSERT_EQ(interestInfoSizeOld + 1, listener->GetInterestInfo().size());
1239 std::unordered_set<WindowInfoKey> observedInfo1;
1240 observedInfo1.insert(WindowInfoKey::BUNDLE_NAME);
1241 ret = WindowManagerLite::GetInstance().UnregisterWindowInfoChangeCallback(observedInfo1, listener);
1242 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1243 }
1244
1245 /**
1246 * @tc.name: RegisterVisibilityStateChangedListener01
1247 * @tc.desc: check RegisterVisibilityStateChangedListener
1248 * @tc.type: FUNC
1249 */
1250 HWTEST_F(WindowManagerLiteTest, RegisterVisibilityStateChangedListener01, Function | SmallTest | Level2)
1251 {
1252 auto& windowManager = WindowManagerLite::GetInstance();
1253 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityStateListenerAgent_;
1254 auto oldListeners = windowManager.pImpl_->windowVisibilityStateListeners_;
1255 windowManager.pImpl_->windowVisibilityStateListenerAgent_ = nullptr;
1256 windowManager.pImpl_->windowVisibilityStateListeners_.clear();
1257 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(nullptr));
1258
1259 sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1260 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1261 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1262 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(listener));
1263 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityStateListenerAgent_);
1264
1265 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1266 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
1267 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1268
1269 // to check that the same listner can not be registered twice
1270 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1271 ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
1272 ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1273
1274 windowManager.pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
1275 windowManager.pImpl_->windowVisibilityStateListeners_ = oldListeners;
1276 }
1277
1278 /**
1279 * @tc.name: UnregisterVisibilityStateChangedListener01
1280 * @tc.desc: check UnregisterVisibilityStateChangedListener
1281 * @tc.type: FUNC
1282 */
1283 HWTEST_F(WindowManagerLiteTest, UnregisterVisibilityStateChangedListener01, Function | SmallTest | Level2)
1284 {
1285 auto& windowManager = WindowManagerLite::GetInstance();
1286 auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityStateListenerAgent_;
1287 auto oldListeners = windowManager.pImpl_->windowVisibilityStateListeners_;
1288 windowManager.pImpl_->windowVisibilityStateListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
1289 windowManager.pImpl_->windowVisibilityStateListeners_.clear();
1290
1291 // check nullpter
1292 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityStateChangedListener(nullptr));
1293
1294 sptr<TestWindowVisibilityStateListener> listener1 = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1295 sptr<TestWindowVisibilityStateListener> listener2 = sptr<TestWindowVisibilityStateListener>::MakeSptr();
1296 ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.UnregisterVisibilityStateChangedListener(listener1));
1297
1298 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1299 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1300 windowManager.RegisterVisibilityStateChangedListener(listener1);
1301 EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1302 windowManager.RegisterVisibilityStateChangedListener(listener2);
1303 ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1304
1305 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener1));
1306 EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1307 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener2));
1308 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1309 ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityStateListenerAgent_);
1310
1311 windowManager.pImpl_->windowVisibilityStateListeners_.emplace_back(listener1);
1312 ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener1));
1313 ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityStateListeners_.size());
1314
1315 windowManager.pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
1316 windowManager.pImpl_->windowVisibilityStateListeners_ = oldListeners;
1317 }
1318
1319 /**
1320 * @tc.name: RegisterCallingWindowDisplayChangedListener1
1321 * @tc.desc: check RegisterCallingWindowDisplayChangedListener
1322 * @tc.type: FUNC
1323 */
1324 HWTEST_F(WindowManagerLiteTest, RegisterCallingWindowDisplayChangedListener1, Function | SmallTest | Level2)
1325 {
1326 sptr<TestIKeyboardCallingWindowDisplayChangedListener> listener
1327 = sptr<TestIKeyboardCallingWindowDisplayChangedListener>::MakeSptr();
1328 auto& windowManager = WindowManagerLite::GetInstance();
1329 windowManager.pImpl_->callingDisplayChangedListeners_.clear();
1330 windowManager.pImpl_->callingDisplayListenerAgent_ = nullptr;
1331 WMError ret = windowManager.RegisterCallingWindowDisplayChangedListener(nullptr);
1332 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1333
1334 ret = windowManager.RegisterCallingWindowDisplayChangedListener(listener);
1335 ASSERT_EQ(WMError::WM_OK, ret);
1336 ASSERT_NE(nullptr, windowManager.pImpl_->callingDisplayListenerAgent_);
1337 ASSERT_EQ(1, static_cast<uint32_t>(windowManager.pImpl_->callingDisplayChangedListeners_.size()));
1338
1339 // Register the same listener repeatedly.
1340 ret = windowManager.RegisterCallingWindowDisplayChangedListener(listener);
1341 ASSERT_EQ(WMError::WM_OK, ret);
1342 ASSERT_EQ(1, static_cast<uint32_t>(windowManager.pImpl_->callingDisplayChangedListeners_.size()));
1343 }
1344
1345 /**
1346 * @tc.name: RegisterCallingWindowDisplayChangedListener2
1347 * @tc.desc: check RegisterCallingWindowDisplayChangedListener
1348 * @tc.type: FUNC
1349 */
1350 HWTEST_F(WindowManagerLiteTest, RegisterCallingWindowDisplayChangedListener2, Function | SmallTest | Level2)
1351 {
1352 sptr<TestIKeyboardCallingWindowDisplayChangedListener> listener1
1353 = sptr<TestIKeyboardCallingWindowDisplayChangedListener>::MakeSptr();
1354 sptr<TestIKeyboardCallingWindowDisplayChangedListener> listener2
1355 = sptr<TestIKeyboardCallingWindowDisplayChangedListener>::MakeSptr();
1356
1357 auto& windowManager = WindowManagerLite::GetInstance();
1358 windowManager.pImpl_->callingDisplayChangedListeners_.clear();
1359 windowManager.pImpl_->callingDisplayListenerAgent_ = nullptr;
1360 WMError ret = windowManager.RegisterCallingWindowDisplayChangedListener(listener1);
1361 ASSERT_EQ(WMError::WM_OK, ret);
1362 ASSERT_NE(nullptr, windowManager.pImpl_->callingDisplayListenerAgent_);
1363 ASSERT_EQ(1, static_cast<uint32_t>(windowManager.pImpl_->callingDisplayChangedListeners_.size()));
1364
1365 ret = windowManager.RegisterCallingWindowDisplayChangedListener(listener2);
1366 ASSERT_EQ(WMError::WM_OK, ret);
1367 ASSERT_EQ(2, static_cast<uint32_t>(windowManager.pImpl_->callingDisplayChangedListeners_.size()));
1368
1369 ret = windowManager.UnregisterCallingWindowDisplayChangedListener(listener1);
1370 ASSERT_EQ(WMError::WM_OK, ret);
1371 ASSERT_EQ(1, static_cast<uint32_t>(windowManager.pImpl_->callingDisplayChangedListeners_.size()));
1372 ASSERT_NE(nullptr, windowManager.pImpl_->callingDisplayListenerAgent_);
1373
1374 // Unregister the same listener repeatedly.
1375 ret = windowManager.UnregisterCallingWindowDisplayChangedListener(listener1);
1376 ASSERT_EQ(WMError::WM_OK, ret);
1377 ASSERT_EQ(1, static_cast<uint32_t>(windowManager.pImpl_->callingDisplayChangedListeners_.size()));
1378
1379 ret = windowManager.UnregisterCallingWindowDisplayChangedListener(listener2);
1380 ASSERT_EQ(WMError::WM_OK, ret);
1381 ASSERT_EQ(0, static_cast<uint32_t>(windowManager.pImpl_->callingDisplayChangedListeners_.size()));
1382 ASSERT_EQ(nullptr, windowManager.pImpl_->callingDisplayListenerAgent_);
1383 }
1384
1385 /**
1386 * @tc.name: RegisterCallingWindowDisplayChangedListener3
1387 * @tc.desc: check RegisterCallingWindowDisplayChangedListener
1388 * @tc.type: FUNC
1389 */
1390 HWTEST_F(WindowManagerLiteTest, RegisterCallingWindowDisplayChangedListener3, Function | SmallTest | Level2)
1391 {
1392 sptr<TestIKeyboardCallingWindowDisplayChangedListener> listener
1393 = sptr<TestIKeyboardCallingWindowDisplayChangedListener>::MakeSptr();
1394
1395 auto& windowManager = WindowManagerLite::GetInstance();
1396 windowManager.pImpl_->callingDisplayChangedListeners_.clear();
1397 windowManager.pImpl_->callingDisplayListenerAgent_ = nullptr;
1398 WMError ret = windowManager.UnregisterCallingWindowDisplayChangedListener(nullptr);
1399 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1400
1401 ret = windowManager.UnregisterCallingWindowDisplayChangedListener(listener);
1402 ASSERT_EQ(WMError::WM_OK, ret);
1403 }
1404
1405 /**
1406 * @tc.name: NotifyCallingWindowDisplayChanged1
1407 * @tc.desc: check NotifyCallingWindowDisplayChanged
1408 * @tc.type: FUNC
1409 */
1410 HWTEST_F(WindowManagerLiteTest, NotifyCallingWindowDisplayChanged1, Function | SmallTest | Level2)
1411 {
1412 sptr<TestIKeyboardCallingWindowDisplayChangedListener> listener
1413 = sptr<TestIKeyboardCallingWindowDisplayChangedListener>::MakeSptr();
1414
1415 auto& windowManager = WindowManagerLite::GetInstance();
1416 windowManager.pImpl_->callingDisplayChangedListeners_.clear();
1417 windowManager.pImpl_->callingDisplayListenerAgent_ = nullptr;
1418
1419 const CallingWindowInfo& callingWindowInfo = {86, 57256, 12, 100};
1420 windowManager.NotifyCallingWindowDisplayChanged(callingWindowInfo);
1421 ASSERT_EQ(false, listener->isNotified);
1422
1423 windowManager.pImpl_->callingDisplayChangedListeners_.emplace_back(nullptr);
1424 windowManager.NotifyCallingWindowDisplayChanged(callingWindowInfo);
1425 ASSERT_EQ(false, listener->isNotified);
1426 }
1427
1428 /**
1429 * @tc.name: NotifyCallingWindowDisplayChanged2
1430 * @tc.desc: check NotifyCallingWindowDisplayChanged
1431 * @tc.type: FUNC
1432 */
1433 HWTEST_F(WindowManagerLiteTest, NotifyCallingWindowDisplayChanged2, Function | SmallTest | Level2)
1434 {
1435 sptr<TestIKeyboardCallingWindowDisplayChangedListener> listener1
1436 = sptr<TestIKeyboardCallingWindowDisplayChangedListener>::MakeSptr();
1437
1438 sptr<TestIKeyboardCallingWindowDisplayChangedListener> listener2
1439 = sptr<TestIKeyboardCallingWindowDisplayChangedListener>::MakeSptr();
1440
1441 auto& windowManager = WindowManagerLite::GetInstance();
1442 windowManager.pImpl_->callingDisplayChangedListeners_.clear();
1443 windowManager.pImpl_->callingDisplayListenerAgent_ = nullptr;
1444
1445 windowManager.pImpl_->callingDisplayChangedListeners_.emplace_back(listener1);
1446 windowManager.pImpl_->callingDisplayChangedListeners_.emplace_back(listener2);
1447
1448 const CallingWindowInfo& callingWindowInfo = {86, 57256, 12, 100};
1449 windowManager.NotifyCallingWindowDisplayChanged(callingWindowInfo);
1450 ASSERT_EQ(true, listener1->isNotified);
1451 ASSERT_EQ(true, listener2->isNotified);
1452 ASSERT_EQ(true, CheckCallingWindowInfo(callingWindowInfo, listener1->info));
1453 ASSERT_EQ(true, CheckCallingWindowInfo(callingWindowInfo, listener2->info));
1454 }
1455 } // namespace
1456 } // namespace OHOS::Rosen